Parse return types and add them to the Vue test

src/compiler/parser.ts

@@ -138,6 +138,8 @@ namespace ts {
             case SyntaxKind.ParenthesizedType:
             case SyntaxKind.TypeOperator:
                 return visitNode(cbNode, (<ParenthesizedTypeNode | TypeOperatorNode>node).type);
+            case SyntaxKind.ReturnOperator:
+                return visitNode(cbNode, (<ReturnOperatorNode>node).type);
             case SyntaxKind.IndexedAccessType:
                 return visitNode(cbNode, (<IndexedAccessTypeNode>node).objectType) ||
                     visitNode(cbNode, (<IndexedAccessTypeNode>node).indexType);
@@ -2611,7 +2613,23 @@ namespace ts {
             return type;
         }
 
-        function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword) {
+        function parseReturnOperator(operator: SyntaxKind.ReturnKeyword): TypeNode {
+            const node = <ReturnOperatorNode>createNode(SyntaxKind.ReturnOperator);
+            parseExpected(operator);
+            node.operator = operator;
+            node.type = parseReturnOperatorOrHigher();
+            return finishNode(node);
+        }
+
+        function parseReturnOperatorOrHigher(): TypeNode {
+            switch (token()) {
+                case SyntaxKind.ReturnKeyword:
+                    return parseReturnOperator(SyntaxKind.ReturnKeyword);
+            }
+            return parseTypeOperatorOrHigher();
+        }
+
+       function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword) {
             const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
             parseExpected(operator);
             node.operator = operator;
@@ -2644,7 +2662,7 @@ namespace ts {
         }
 
         function parseIntersectionTypeOrHigher(): TypeNode {
-            return parseUnionOrIntersectionType(SyntaxKind.IntersectionType, parseTypeOperatorOrHigher, SyntaxKind.AmpersandToken);
+            return parseUnionOrIntersectionType(SyntaxKind.IntersectionType, parseReturnOperatorOrHigher, SyntaxKind.AmpersandToken);
         }
 
         function parseUnionTypeOrHigher(): TypeNode {

src/compiler/types.ts

@@ -238,6 +238,7 @@
         ParenthesizedType,
         ThisType,
         TypeOperator,
+        ReturnOperator,
         IndexedAccessType,
         MappedType,
         LiteralType,
@@ -917,6 +918,12 @@
         type: TypeNode;
     }
 
+    export interface ReturnOperatorNode extends TypeNode {
+        kind: SyntaxKind.ReturnOperator;
+        operator: SyntaxKind.ReturnKeyword;
+        type: TypeNode;
+    }
+
     export interface IndexedAccessTypeNode extends TypeNode {
         kind: SyntaxKind.IndexedAccessType;
         objectType: TypeNode;

tests/cases/compiler/recursion.ts

@@ -14,7 +14,7 @@ let x = o.m()  // x: number
 let y = o.m2() // y: any
 let p = o.p    // p: number
 
-type Propertise<T> = { [K in keyof T]: T[K] };
+type Propertise<T> = { [K in keyof T]: return T[K] };
 type Vue<T extends { data, methods, properties }> = T['data'] & T['methods'] & Propertise<T['properties']>;
 
 let options = {