Changed check on annotated functions/getters to only look for return statements.

Author: DanielRosenwasser

src/compiler/checker.ts

@@ -3963,13 +3963,13 @@ module ts {
             return voidType;
         }
 
-        // WARNING: This has the same semantics as forEach, in that traversal terminates
-        //          in the event that 'visitor' supplies a truthy value!
-        function visitReturnStatements<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {
+        // WARNING: This has the same semantics as the forEach family of functions,
+        //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
+        function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {
 
-            return visitHelper(body);
+            return traverse(body);
 
-            function visitHelper(node: Node): T {
+            function traverse(node: Node): T {
                 switch (node.kind) {
                     case SyntaxKind.ReturnStatement:
                         return visitor(node);
@@ -3989,7 +3989,7 @@ module ts {
                     case SyntaxKind.TryBlock:
                     case SyntaxKind.CatchBlock:
                     case SyntaxKind.FinallyBlock:
-                        return forEachChild(node, visitHelper);
+                        return forEachChild(node, traverse);
                 }
             }
         }
@@ -3998,7 +3998,7 @@ module ts {
         function checkAndAggregateReturnExpressionTypes(body: Block, contextualType?: Type, contextualMapper?: TypeMapper): Type[] {
             var aggregatedTypes: Type[] = [];
 
-            visitReturnStatements(body, (returnStatement) => {
+            forEachReturnStatement(body, (returnStatement) => {
                 var expr = returnStatement.expression;
                 if (expr) {
                     var type = checkAndMarkExpression(expr, contextualType, contextualMapper);
@@ -4011,9 +4011,9 @@ module ts {
             return aggregatedTypes;
         }
 
-        function bodyContainsReturnExpressions(funcBody: Block) {
-            return visitReturnStatements(funcBody, (returnStatement) => {
-                return returnStatement.expression !== undefined;
+        function bodyContainsAReturnStatement(funcBody: Block) {
+            return forEachReturnStatement(funcBody, (returnStatement) => {
+                return true;
             });
         }
 
@@ -4039,7 +4039,7 @@ module ts {
             var bodyBlock = <Block>func.body;
 
             // Ensure the body has at least one return expression.
-            if (bodyContainsReturnExpressions(bodyBlock)) {
+            if (bodyContainsAReturnStatement(bodyBlock)) {
                 return;
             }
 
@@ -4653,7 +4653,7 @@ module ts {
 
         function checkAccessorDeclaration(node: AccessorDeclaration) {
             if (node.kind === SyntaxKind.GetAccessor) {
-                if (!isInAmbientContext(node) && node.body && !(bodyContainsReturnExpressions(<Block>node.body) || bodyContainsSingleThrowStatement(<Block>node.body))) {
+                if (!isInAmbientContext(node) && node.body && !(bodyContainsAReturnStatement(<Block>node.body) || bodyContainsSingleThrowStatement(<Block>node.body))) {
                     error(node.name, Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);
                 }
             }

tests/baselines/reference/functionImplementations.errors.txt

@@ -0,0 +1,129 @@
+==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ====
+    
+    function f1(): string {
+                   ~~~~~~
+!!! A function whose declared type is neither 'void' nor 'any' must have a 'return' expression or consist of a single 'throw' statement.
+        // errors because there are no return statements
+    }
+    
+    function f2(): string {
+        // Permissible; returns undefined.
+        return;
+    }
+    
+    function f3(): string {
+        return "Okay, because this is a return expression.";
+    }
+    
+    function f4(): void {
+        // Fine since we are typed void.
+    }
+    
+    function f5(): void {
+        // Fine since we are typed void.
+        return;
+    }
+    
+    function f6(): void {
+        // Fine since we are typed void and return undefined
+        return undefined;
+    }
+    
+    function f7(): void {
+        // Fine since we are typed void and return null
+        return null;
+    }
+    
+    function f8(): void {
+        // Fine since are typed any.
+        return;
+    }
+    
+    function f9(): void {
+        // Fine since we are typed any and return undefined
+        return undefined;
+    }
+    
+    function f10(): void {
+        // Fine since we are typed any and return null
+        return null;
+    }
+    
+    function f11(): string {
+        // Fine since we consist of a single throw statement.
+        throw undefined;
+    }
+    
+    function f12(): void {
+        // Fine since we consist of a single throw statement.
+        throw undefined;
+    }
+    
+    function f13(): any {
+        // Fine since we consist of a single throw statement.
+        throw undefined;
+    }
+    
+    function f14(): number {
+                    ~~~~~~
+!!! A function whose declared type is neither 'void' nor 'any' must have a 'return' expression or consist of a single 'throw' statement.
+        // Not fine, since we can *only* consist of a single throw statement
+        // if no return statements are present but we are annotated.
+        throw undefined;
+        throw null;
+    }
+    
+    function f15(): number {
+        // Fine, since we have a return statement somewhere.
+        throw undefined;
+        throw null;
+        return;
+    }
+    
+    
+    function f16() {
+        // Okay; not type annotated.
+    }
+    
+    function f17() {
+        // Okay; not type annotated.
+        return;
+    }
+    
+    function f18() {
+        return "Okay, not type annotated.";
+    }
+    
+    
+    class C {
+        public get m1() {
+                   ~~
+!!! A 'get' accessor must return a value or consist of a single 'throw' statement.
+            // Errors; get accessors must return a value.
+        }
+    
+        public get m2() {
+            // Permissible; returns undefined.
+            return;
+        }
+    
+        public get m3() {
+            return "Okay, because this is a return expression.";
+        }
+    
+        public get m4() {
+            // Fine since this consists of a single throw statement.
+            throw null;
+        }
+    
+        public get m5() {
+                   ~~
+!!! A 'get' accessor must return a value or consist of a single 'throw' statement.
+            // Not fine, since we can *only* consist of a single throw statement
+            // if no return statements are present but we are a get accessor.
+            throw null;
+            throw undefined.
+        }
+        ~
+!!! Identifier expected.
+    }

tests/baselines/reference/functionReturn.errors.txt

@@ -1,6 +1,4 @@
-==== tests/cases/conformance/parser/ecmascript5/Statements/ReturnStatements/parserReturnStatement4.ts (2 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/ReturnStatements/parserReturnStatement4.ts (1 errors) ====
     var v = { get foo() { return } };
                   ~~~
-!!! Accessors are only available when targeting ECMAScript 5 and higher.
-                  ~~~
-!!! A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! Accessors are only available when targeting ECMAScript 5 and higher.