Adds 'promised' type to better handle promise resolution and await

Author: rbuckton

Gulpfile.ts

@@ -1032,7 +1032,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
     const fileMatcher = cmdLineOptions["files"];
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
-        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
+        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts' --exclude 'src/lib/es2015.iterable.d.ts' --exclude 'src/lib/es2015.promise.d.ts'";
     const cmd = `node node_modules/tslint/bin/tslint ${files} --format stylish`;
     console.log("Linting: " + cmd);
     child_process.execSync(cmd, { stdio: [0, 1, 2] });

Jakefile.js

@@ -1208,7 +1208,7 @@ task("lint", ["build-rules"], () => {
     const fileMatcher = process.env.f || process.env.file || process.env.files;
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
-        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";
+        : "Gulpfile.ts 'scripts/tslint/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts' --exclude 'src/lib/es2015.iterable.d.ts' --exclude 'src/lib/es2015.promise.d.ts'";
     const cmd = `node node_modules/tslint/bin/tslint ${files} --format stylish`;
     console.log("Linting: " + cmd);
     jake.exec([cmd], { interactive: true }, () => {

src/compiler/checker.ts

@@ -627,15 +627,15 @@ namespace ts {
         return <ThisTypeNode>createSynthesizedNode(SyntaxKind.ThisType);
     }
 
-    export function createTypeOperatorNode(type: TypeNode) {
+    export function createTypeOperatorNode(type: TypeNode, operator: SyntaxKind.KeyOfKeyword | SyntaxKind.PromisedKeyword) {
         const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;
-        node.operator = SyntaxKind.KeyOfKeyword;
+        node.operator = operator;
         node.type = parenthesizeElementTypeMember(type);
         return node;
     }
 
     export function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode) {
-        return node.type !== type ? updateNode(createTypeOperatorNode(type), node) : node;
+        return node.type !== type ? updateNode(createTypeOperatorNode(type, node.operator), node) : node;
     }
 
     export function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode) {

src/compiler/factory.ts

@@ -2663,7 +2663,7 @@ namespace ts {
             return type;
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword) {
+        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.PromisedKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -2672,9 +2672,11 @@ namespace ts {
         }
 
         function parseTypeOperatorOrHigher(): TypeNode {
-            switch (token()) {
+            const keyword = token();
+            switch (keyword) {
                 case SyntaxKind.KeyOfKeyword:
-                    return parseTypeOperator(SyntaxKind.KeyOfKeyword);
+                case SyntaxKind.PromisedKeyword:
+                    return parseTypeOperator(keyword);
             }
             return parseArrayTypeOrHigher();
         }

src/compiler/parser.ts

@@ -104,6 +104,7 @@ namespace ts {
         "package": SyntaxKind.PackageKeyword,
         "private": SyntaxKind.PrivateKeyword,
         "protected": SyntaxKind.ProtectedKeyword,
+        "promised": SyntaxKind.PromisedKeyword,
         "public": SyntaxKind.PublicKeyword,
         "readonly": SyntaxKind.ReadonlyKeyword,
         "require": SyntaxKind.RequireKeyword,

src/compiler/scanner.ts

@@ -192,6 +192,7 @@ namespace ts {
         ModuleKeyword,
         NamespaceKeyword,
         NeverKeyword,
+        PromisedKeyword,
         ReadonlyKeyword,
         RequireKeyword,
         NumberKeyword,
@@ -986,7 +987,7 @@ namespace ts {
 
     export interface TypeOperatorNode extends TypeNode {
         kind: SyntaxKind.TypeOperator;
-        operator: SyntaxKind.KeyOfKeyword;
+        operator: SyntaxKind.KeyOfKeyword | SyntaxKind.PromisedKeyword;
         type: TypeNode;
     }
 
@@ -3157,17 +3158,18 @@ namespace ts {
         Intersection            = 1 << 17,  // Intersection (T & U)
         Index                   = 1 << 18,  // keyof T
         IndexedAccess           = 1 << 19,  // T[K]
+        Promised                = 1 << 20,  // promised T
         /* @internal */
-        FreshLiteral            = 1 << 20,  // Fresh literal type
+        FreshLiteral            = 1 << 21,  // Fresh literal type
         /* @internal */
-        ContainsWideningType    = 1 << 21,  // Type is or contains undefined or null widening type
+        ContainsWideningType    = 1 << 22,  // Type is or contains undefined or null widening type
         /* @internal */
-        ContainsObjectLiteral   = 1 << 22,  // Type is or contains object literal type
+        ContainsObjectLiteral   = 1 << 23,  // Type is or contains object literal type
         /* @internal */
-        ContainsAnyFunctionType = 1 << 23,  // Type is or contains object literal type
-        NonPrimitive            = 1 << 24,  // intrinsic object type
+        ContainsAnyFunctionType = 1 << 24,  // Type is or contains object literal type
+        NonPrimitive            = 1 << 25,  // intrinsic object type
         /* @internal */
-        JsxAttributes           = 1 << 25,  // Jsx attributes type
+        JsxAttributes           = 1 << 26,  // Jsx attributes type
 
         /* @internal */
         Nullable = Undefined | Null,
@@ -3186,12 +3188,12 @@ namespace ts {
         EnumLike = Enum | EnumLiteral,
         UnionOrIntersection = Union | Intersection,
         StructuredType = Object | Union | Intersection,
-        StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess,
+        StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess | Promised,
         TypeVariable = TypeParameter | IndexedAccess,
 
         // 'Narrowable' types are types where narrowing actually narrows.
         // This *should* be every type other than null, undefined, void, and never
-        Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | NonPrimitive,
+        Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | NonPrimitive | Promised,
         NotUnionOrUnit = Any | ESSymbol | Object | NonPrimitive,
         /* @internal */
         RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
@@ -3313,6 +3315,8 @@ namespace ts {
         resolvedBaseConstraint: Type;
         /* @internal */
         couldContainTypeVariables: boolean;
+        /* @internal */
+        resolvedPromisedType: PromisedType;
     }
 
     export interface UnionType extends UnionOrIntersectionType { }
@@ -3376,16 +3380,17 @@ namespace ts {
 
     /* @internal */
     export interface PromiseOrAwaitableType extends ObjectType, UnionType {
-        promiseTypeOfPromiseConstructor?: Type;
-        promisedTypeOfPromise?: Type;
-        awaitedTypeOfType?: Type;
+        fulfillmentType?: Type;     // Type of `value` parameter of `onfulfilled` callback.
+        promisedType?: Type;        // The "fulfillment type" if a Promise-like, otherwise this type.
     }
 
     export interface TypeVariable extends Type {
         /* @internal */
         resolvedBaseConstraint: Type;
         /* @internal */
         resolvedIndexType: IndexType;
+        /* @internal */
+        resolvedPromisedType: PromisedType;
     }
 
     // Type parameters (TypeFlags.TypeParameter)
@@ -3415,6 +3420,11 @@ namespace ts {
         type: TypeVariable | UnionOrIntersectionType;
     }
 
+    // promised T types (TypeFlags.Promised)
+    export interface PromisedType extends Type {
+        type: TypeVariable;
+    }
+
     export const enum SignatureKind {
         Call,
         Construct,

src/compiler/types.ts

@@ -197,15 +197,15 @@ interface PromiseConstructor {
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    all<TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>;
+    all<TAll>(values: Iterable<TAll>): Promise<(promised TAll)[]>;
 
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
      */
-    race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>;
+    race<T>(values: Iterable<T>): Promise<promised T>;
 }
 
 declare namespace Reflect {