Initial support for $ReadOnlyArray

packages/babel-plugin-flow-runtime/src/ConversionContext.js

@@ -21,6 +21,7 @@ const FLOW_TYPENAMES = {
   $Supertype: '$supertype',
   $TupleMap: '$tupleMap',
   $Values: '$values',
+  $ReadOnlyArray: '$readOnlyArray',
   Class: 'Class'
 };
 

packages/babel-plugin-flow-runtime/src/__tests__/__fixtures__/bugs/199-support-$ReadOnlyArray.js

@@ -0,0 +1,14 @@
+/* @flow */
+
+export const input = `
+type Demo = $ReadOnlyArray<number>;
+const test: Demo = [123];
+test.push(4);
+`;
+
+export const expected = `
+import t from "flow-runtime";
+const Demo = t.type("Demo", t.$readOnlyArray(t.number()));
+const test = Demo.assert([123]);
+test.push(4);
+`;

packages/flow-runtime/src/TypeContext.js

@@ -43,6 +43,7 @@ import {
   SymbolLiteralType,
   StringType,
   StringLiteralType,
+  $ReadOnlyArrayType,
   ArrayType,
   ObjectType,
   ObjectTypeCallProperty,
@@ -222,7 +223,7 @@ export default class TypeContext {
     }
     // @flowIssue 252
     const inferrer = this[InferrerSymbol];
-    (inferrer: TypeInferrer);
+    /*:: (inferrer: TypeInferrer); */
 
     return inferrer.infer(input);
   }
@@ -906,6 +907,12 @@ export default class TypeContext {
     return target;
   }
 
+  $readOnlyArray <T> (elementType?: Type<T>): $ReadOnlyArrayType<T> {
+    const target = new $ReadOnlyArrayType(this);
+    target.elementType = elementType || this.any();
+    return target;
+  }
+
   tuple <T> (...types: Type<T>[]): TupleType<any> {
     const target = new TupleType(this);
     target.types = types;

packages/flow-runtime/src/__tests__/__fixtures__/$ReadOnlyArray/subtyping$ReadOnlyArray.js

@@ -0,0 +1,15 @@
+/* @flow */
+
+import type TypeContext from '../../../TypeContext';
+
+export function pass(t: TypeContext) {
+  const bar = t.array(t.number()).assert([-1, 1, 2, 3]);
+  const baz = t.$readOnlyArray(t.number()).assert(bar);
+  return baz;
+}
+
+export function fail(t: TypeContext) {
+  const bar = t.$readOnlyArray(t.number()).assert([0, 1, 2, 3]);
+  const baz = t.array(t.number()).assert(bar);
+  return baz;
+}

packages/flow-runtime/src/__tests__/__fixtures__/bugs/199-support-$ReadOnlyArray.js

@@ -0,0 +1,18 @@
+/* @flow */
+
+import type TypeContext from '../../../TypeContext';
+
+export function pass(t: TypeContext) {
+  const Demo = t.type('Demo', t.$readOnlyArray(t.number(123)));
+
+  return Demo.assert([123]);
+}
+
+export function fail(t: TypeContext) {
+  const Demo = t.type('Demo', t.$readOnlyArray(t.number(123)));
+
+  const arr = Demo.assert([123]);
+  arr.push(4);
+
+  return arr;
+}

packages/flow-runtime/src/index.js

@@ -2,12 +2,10 @@
 
 import globalContext from './globalContext';
 
-import {
-  TypeParametersSymbol,
-  TypeSymbol
-} from './symbols';
+import { TypeParametersSymbol, TypeSymbol } from './symbols';
 
 import AnyType from './types/AnyType';
+import $ReadOnlyArrayType from './types/$ReadOnlyArrayType';
 import ArrayType from './types/ArrayType';
 import BooleanLiteralType from './types/BooleanLiteralType';
 import BooleanType from './types/BooleanType';
@@ -64,6 +62,7 @@ export default globalContext;
 
 export {
   AnyType,
+  $ReadOnlyArrayType,
   ArrayType,
   BooleanLiteralType,
   BooleanType,
@@ -106,7 +105,6 @@ export {
   TypeTDZ,
   UnionType,
   VoidType,
-
   Declaration,
   TypeDeclaration,
   VarDeclaration,
@@ -115,7 +113,6 @@ export {
   ClassDeclaration,
   ParameterizedClassDeclaration,
   ExtendsDeclaration,
-
   TypeParametersSymbol,
-  TypeSymbol
+  TypeSymbol,
 };

packages/flow-runtime/src/registerTypePredicates.js

@@ -3,6 +3,8 @@
 import type TypeContext from './TypeContext';
 
 export default function registerTypePredicates (context: TypeContext) {
+  // TODO: make better subtyping rules
+  context.setPredicate('$ReadOnlyArray', (input: any) => Array.isArray(input) && Object.isFrozen(input));
   context.setPredicate('Array', (input: any) => Array.isArray(input));
   context.setPredicate('Map', (input: any) => input instanceof Map);
   context.setPredicate('Set', (input: any) => input instanceof Set);

packages/flow-runtime/src/types/$ReadOnlyArrayType.js

@@ -0,0 +1,111 @@
+/* @flow */
+
+import Type from '../types/Type';
+import TupleType from '../types/TupleType';
+import ArrayType from '../types/ArrayType';
+import compareTypes from '../compareTypes';
+import getErrorMessage from '../getErrorMessage';
+import type Validation, {ErrorTuple, IdentifierPath} from '../Validation';
+
+import {
+  inValidationCycle,
+  startValidationCycle,
+  endValidationCycle,
+  inToStringCycle,
+  startToStringCycle,
+  endToStringCycle,
+} from '../cyclic';
+
+export default class $ReadOnlyArrayType<T> extends Type<$ReadOnlyArray<T>> {
+  typeName: string = '$ReadOnlyArrayType';
+  elementType: Type<T>;
+
+  *errors(
+    validation: Validation<any>,
+    path: IdentifierPath,
+    input: any,
+  ): Generator<ErrorTuple, void, void> {
+    const {context} = this;
+    if (!context.checkPredicate('Array', input)) {
+      yield [path, getErrorMessage('ERR_EXPECT_ARRAY'), this];
+      return;
+    }
+    if (validation.inCycle(this, input)) {
+      return;
+    }
+    validation.startCycle(this, input);
+    const {elementType} = this;
+    const {length} = input;
+
+    for (let i = 0; i < length; i++) {
+      yield* elementType.errors(validation, path.concat(i), input[i]);
+    }
+    if (context.mode === 'assert') {
+      Object.freeze(input);
+    } else {
+      // TODO: support warning mode somehow
+    }
+    validation.endCycle(this, input);
+  }
+
+  accepts(input: any): boolean {
+    const {context} = this;
+    if (!context.checkPredicate('Array', input)) {
+      return false;
+    }
+    if (inValidationCycle(this, input)) {
+      return true;
+    }
+    startValidationCycle(this, input);
+    const {elementType} = this;
+    const {length} = input;
+    for (let i = 0; i < length; i++) {
+      if (!elementType.accepts(input[i])) {
+        endValidationCycle(this, input);
+        return false;
+      }
+    }
+    endValidationCycle(this, input);
+    return true;
+  }
+
+  compareWith(input: Type<any>): -1 | 0 | 1 {
+    const {elementType} = this;
+    if (input instanceof TupleType) {
+      const {types} = input;
+      for (let i = 0; i < types.length; i++) {
+        const result = compareTypes(elementType, types[i]);
+        if (result === -1) {
+          return -1;
+        }
+      }
+      return 1;
+    } else if (input instanceof ArrayType) {
+      return compareTypes(elementType, input.elementType);
+    } else {
+      return -1;
+    }
+  }
+
+  toString(): string {
+    const {elementType} = this;
+    if (inToStringCycle(this)) {
+      if (typeof elementType.name === 'string') {
+        return `$ReadOnlyArray<$Cycle<${elementType.name}>>`;
+      } else {
+        return `$ReadOnlyArray<$Cycle<Object>>`;
+      }
+    }
+    startToStringCycle(this);
+    const output = `$ReadOnlyArray<${elementType.toString()}>`;
+    endToStringCycle(this);
+    return output;
+  }
+
+  toJSON() {
+    return {
+      typeName: this.typeName,
+      elementType: this.elementType,
+    };
+  }
+}

packages/flow-runtime/src/types/ArrayType.js

@@ -2,9 +2,10 @@
 
 import Type from './Type';
 import TupleType from './TupleType';
+import $ReadOnlyArrayType from './$ReadOnlyArrayType';
 import compareTypes from '../compareTypes';
 
-import getErrorMessage from "../getErrorMessage";
+import getErrorMessage from '../getErrorMessage';
 import type Validation, {ErrorTuple, IdentifierPath} from '../Validation';
 
 import {
@@ -13,16 +14,20 @@ import {
   endValidationCycle,
   inToStringCycle,
   startToStringCycle,
-  endToStringCycle
+  endToStringCycle,
 } from '../cyclic';
 
-export default class ArrayType <T> extends Type {
+export default class ArrayType<T> extends Type<Array<T>> {
   typeName: string = 'ArrayType';
   elementType: Type<T>;
 
-  *errors (validation: Validation<any>, path: IdentifierPath, input: any): Generator<ErrorTuple, void, void> {
+  *errors(
+    validation: Validation<any>,
+    path: IdentifierPath,
+    input: any,
+  ): Generator<ErrorTuple, void, void> {
     const {context} = this;
-    if (!context.checkPredicate('Array', input)) {
+    if (!context.checkPredicate('Array', input) || context.checkPredicate('$ReadOnlyArray', input)) {
       yield [path, getErrorMessage('ERR_EXPECT_ARRAY'), this];
       return;
     }
@@ -39,7 +44,7 @@ export default class ArrayType <T> extends Type {
     validation.endCycle(this, input);
   }
 
-  accepts (input: any): boolean {
+  accepts(input: any): boolean {
     const {context} = this;
     if (!context.checkPredicate('Array', input)) {
       return false;
@@ -60,7 +65,7 @@ export default class ArrayType <T> extends Type {
     return true;
   }
 
-  compareWith (input: Type<any>): -1 | 0 | 1 {
+  compareWith(input: Type<any>): -1 | 0 | 1 {
     const {elementType} = this;
     if (input instanceof TupleType) {
       const {types} = input;
@@ -71,22 +76,21 @@ export default class ArrayType <T> extends Type {
         }
       }
       return 1;
-    }
-    else if (input instanceof ArrayType) {
+    } else if (input instanceof ArrayType) {
       return compareTypes(elementType, input.elementType);
-    }
-    else {
+    } else if (input instanceof $ReadOnlyArrayType) {
+      return compareTypes(elementType, input.elementType);
+    } else {
       return -1;
     }
   }
 
-  toString (): string {
+  toString(): string {
     const {elementType} = this;
     if (inToStringCycle(this)) {
       if (typeof elementType.name === 'string') {
         return `Array<$Cycle<${elementType.name}>>`;
-      }
-      else {
+      } else {
         return `Array<$Cycle<Object>>`;
       }
     }
@@ -96,10 +100,10 @@ export default class ArrayType <T> extends Type {
     return output;
   }
 
-  toJSON () {
+  toJSON() {
     return {
       typeName: this.typeName,
-      elementType: this.elementType
+      elementType: this.elementType,
     };
   }
 }