feat: #278 - Add Type.isTupleType

dsherret · Mar 17, 2018 · d7c3c3d · d7c3c3d
1 parent f6d85f3
commit d7c3c3d
Show file tree

Hide file tree

Showing 2 changed files with 52 additions and 12 deletions.
diff --git a/src/compiler/type/Type.ts b/src/compiler/type/Type.ts
@@ -304,6 +304,16 @@ export class Type<TType extends ts.Type = ts.Type> {
         return (this.compilerType.flags & TypeFlags.TypeParameter) !== 0;
     }
 
+    /**
+     * Gets if this is a tuple type.
+     */
+    isTupleType() {
+        const targetType = this.getTargetType();
+        if (targetType == null)
+            return false;
+        return (targetType.getObjectFlags() & ObjectFlags.Tuple) !== 0;
+    }
+
     /**
      * Gets if this is a union type.
      */

diff --git a/src/tests/compiler/type/typeTests.ts b/src/tests/compiler/type/typeTests.ts
@@ -267,6 +267,48 @@ describe(nameof(Type), () => {
         });
     });
 
+    describe(nameof<Type>(t => t.isTupleType), () => {
+        function doTest(text: string, expected: boolean) {
+            const {firstType} = getTypeFromText(text);
+            expect(firstType.isTupleType()).to.equal(expected);
+        }
+
+        it("should be when tuple and one element", () => {
+            doTest("let myType: [string];", true);
+        });
+
+        it("should be when tuple and multiple", () => {
+            doTest("let myType: [string, number];", true);
+        });
+
+        it("should not be when not an array", () => {
+            doTest("let myType: string[];", false);
+        });
+
+        it("should not be when not an array of tuples", () => {
+            doTest("let myType: [string][];", false);
+        });
+
+        it("should not be when not tuple", () => {
+            doTest("let myType: string;", false);
+        });
+    });
+
+    describe(nameof<Type>(t => t.isUndefinedType), () => {
+        function doTest(text: string, expected: boolean) {
+            const {firstType} = getTypeFromText(text);
+            expect(firstType.isUndefinedType()).to.equal(expected);
+        }
+
+        it("should be when undefined", () => {
+            doTest("let myType: undefined;", true);
+        });
+
+        it("should not be when not undefined", () => {
+            doTest("let myType: string;", false);
+        });
+    });
+
     describe(nameof<Type>(t => t.getFlags), () => {
         it("should get the type flags", () => {
             const {firstType} = getTypeFromText("let myType: number;");
@@ -467,16 +509,4 @@ describe(nameof(Type), () => {
             expect(typeArgs[0].getText()).to.equal("string");
         });
     });
-
-    describe(nameof<Type>(t => t.isUndefinedType), () => {
-        it("should not be undefined when not undefined", () => {
-            const {firstType} = getTypeFromText("let myType: string;");
-            expect(firstType.isUndefinedType()).to.be.false;
-        });
-
-        it("should be undefined when not undefined", () => {
-            const {firstType} = getTypeFromText("let myType: undefined;");
-            expect(firstType.isUndefinedType()).to.be.true;
-        });
-    });
 });