Add isArrayLike builtin (AssemblyScript#453)

Author: MaxGraey

src/builtins.ts

@@ -47,6 +47,7 @@ import {
 
 import {
   ElementKind,
+  OperatorKind,
   FunctionPrototype,
   Class,
   Field,
@@ -64,7 +65,7 @@ import {
 } from "./resolver";
 
 import {
-  CommonFlags, CommonSymbols
+  CommonFlags
 } from "./common";
 
 /** Symbols of various compiler built-ins. */
@@ -76,6 +77,7 @@ export namespace BuiltinSymbols {
   export const isReference = "~lib/builtins/isReference";
   export const isString = "~lib/builtins/isString";
   export const isArray = "~lib/builtins/isArray";
+  export const isArrayLike = "~lib/builtins/isArrayLike";
   export const isFunction = "~lib/builtins/isFunction";
   export const isNullable = "~lib/builtins/isNullable";
   export const isDefined = "~lib/builtins/isDefined";
@@ -350,6 +352,19 @@ export function compileCall(
           : 0
       );
     }
+    case BuiltinSymbols.isArrayLike: { // isArrayLike<T!>() / isArrayLike<T?>(value: T) -> bool
+      let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);
+      compiler.currentType = Type.bool;
+      if (!type) return module.createUnreachable();
+      let classReference = type.classReference;
+      if (!classReference) return module.createI32(0);
+      return module.createI32(
+        classReference.lookupInSelf("length") && (
+          classReference.lookupOverload(OperatorKind.INDEXED_GET) ||
+          classReference.lookupOverload(OperatorKind.UNCHECKED_INDEXED_GET)
+        ) ? 1 : 0
+      );
+    }
     case BuiltinSymbols.isFunction: { // isFunction<T!> / isFunction<T?>(value: T) -> bool
       let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);
       compiler.currentType = Type.bool;

std/assembly/builtins.ts

@@ -9,6 +9,7 @@
 @builtin export declare function isReference<T>(value?: T): bool;
 @builtin export declare function isString<T>(value?: T): bool;
 @builtin export declare function isArray<T>(value?: T): bool;
+@builtin export declare function isArrayLike<T>(value?: T): bool;
 @builtin export declare function isFunction<T>(value?: T): bool;
 @builtin export declare function isNullable<T>(value?: T): bool;
 @builtin export declare function isDefined(expression: void): bool;

std/assembly/index.d.ts

@@ -128,6 +128,8 @@ declare function isReference<T>(value?: any): value is object | string;
 declare function isString<T>(value?: any): value is string | String;
 /** Tests if the specified type *or* expression can be used as an array. Compiles to a constant. */
 declare function isArray<T>(value?: any): value is Array<any>;
+/** Tests if the specified type *or* expression can be used as an array like object. Compiles to a constant. */
+declare function isArrayLike<T>(value?: any): value is ArrayLike<any>;
 /** Tests if the specified type *or* expression is of a function type. Compiles to a constant. */
 declare function isFunction<T>(value?: any): value is (...args: any) => any;
 /** Tests if the specified type *or* expression is of a nullable reference type. Compiles to a constant. */
@@ -559,6 +561,11 @@ declare class DataView {
   toString(): string;
 }
 
+interface ArrayLike<T> {
+  length: i32;
+  // [key: number]: T;
+}
+
 /** Interface for a typed view on an array buffer. */
 interface ArrayBufferView<T> {
   [key: number]: T;

std/portable/index.d.ts

@@ -106,6 +106,8 @@ declare function isReference(value: any): value is object | string;
 declare function isString(value: any): value is string | String;
 /** Tests if the specified value can be used as an array. */
 declare function isArray(value: any): value is Array<any>;
+/** Tests if the specified type *or* expression can be used as an array like object. Compiles to a constant. */
+declare function isArrayLike(value: any): value is ArrayLike<any>;
 /** Tests if the specified expression resolves to a defined element. */
 declare function isDefined(expression: any): bool;
 /** Tests if the specified expression evaluates to a constant value. */
@@ -411,6 +413,11 @@ declare class Int32Array extends Array<i32> {}
 declare class Float32Array extends Array<f32> {}
 declare class Float64Array extends Array<f64> {}
 
+interface ArrayLike<T> {
+  length: i32;
+  [key: number]: T;
+}
+
 /** Interface for a typed view on an array buffer. */
 interface ArrayBufferView<T> {
   [key: number]: T;

std/portable/index.js

@@ -215,6 +215,13 @@ globalScope["isString"] = function isString(arg) {
 };
 
 globalScope["isArray"] = Array.isArray;
+globalScope["isArrayLike"] = function isArrayLike(expr) {
+  return expr
+    && typeof expr === 'object'
+    && typeof expr.length === 'number'
+    && expr.length >= 0
+    && Math.trunc(expr.length) === expr.length;
+}
 
 globalScope["isDefined"] = function isDefined(expr) {
   return typeof expr !== "undefined";

tests/compiler/builtins.optimized.wat

@@ -43,7 +43,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 59
+   i32.const 66
    i32.const 19
    call $~lib/env/abort
    unreachable
@@ -56,7 +56,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 60
+   i32.const 67
    i32.const 20
    call $~lib/env/abort
    unreachable
@@ -69,7 +69,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 61
+   i32.const 68
    i32.const 20
    call $~lib/env/abort
    unreachable
@@ -92,7 +92,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 77
+   i32.const 84
    i32.const 19
    call $~lib/env/abort
    unreachable
@@ -105,7 +105,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 78
+   i32.const 85
    i32.const 20
    call $~lib/env/abort
    unreachable
@@ -118,7 +118,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 79
+   i32.const 86
    i32.const 20
    call $~lib/env/abort
    unreachable

tests/compiler/builtins.ts

@@ -11,6 +11,10 @@ assert(isReference<string>());
 assert(!isReference<usize>());
 assert(isArray<i32[]>());
 assert(!isArray<usize>());
+assert(isArrayLike<i32[]>());
+assert(isArrayLike<string>());
+assert(isArrayLike<Uint8Array>());
+assert(!isArrayLike<i32>());
 assert(isFunction<() => void>());
 assert(!isFunction<u32>());
 assert(isNullable<C | null>());
@@ -25,6 +29,9 @@ assert(!isReference(changetype<usize>(null)));
 assert(isString("1"));
 assert(!isString(1));
 assert(isArray(changetype<i32[]>(null)));
+assert(isArrayLike(changetype<i32[]>(null)));
+assert(isArrayLike(changetype<string>(null)));
+assert(isArrayLike(changetype<Uint8Array>(null)));
 assert(!isArray(changetype<usize>(null)));
 assert(isFunction(changetype<() => void>(null)));
 assert(!isFunction(changetype<u32>(null)));