Disallow exprs of type void to be used in truthiness checks

Author: RyanCavanaugh

src/compiler/checker.ts

@@ -24512,7 +24512,7 @@ namespace ts {
             // Grammar checking
             checkGrammarStatementInAmbientContext(node);
 
-            checkExpression(node.expression);
+            checkTruthinessExpression(node.expression);
             checkSourceElement(node.thenStatement);
 
             if (node.thenStatement.kind === SyntaxKind.EmptyStatement) {
@@ -24527,17 +24527,25 @@ namespace ts {
             checkGrammarStatementInAmbientContext(node);
 
             checkSourceElement(node.statement);
-            checkExpression(node.expression);
+            checkTruthinessExpression(node.expression);
         }
 
         function checkWhileStatement(node: WhileStatement) {
             // Grammar checking
             checkGrammarStatementInAmbientContext(node);
 
-            checkExpression(node.expression);
+            checkTruthinessExpression(node.expression);
             checkSourceElement(node.statement);
         }
 
+        function checkTruthinessExpression(node: Expression) {
+            const type = checkExpression(node);
+            if (type === voidType) {
+                error(node, Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness);
+            }
+            return type;
+        }
+
         function checkForStatement(node: ForStatement) {
             // Grammar checking
             if (!checkGrammarStatementInAmbientContext(node)) {
@@ -24555,7 +24563,7 @@ namespace ts {
                 }
             }
 
-            if (node.condition) checkExpression(node.condition);
+            if (node.condition) checkTruthinessExpression(node.condition);
             if (node.incrementor) checkExpression(node.incrementor);
             checkSourceElement(node.statement);
             if (node.locals) {

src/compiler/diagnosticMessages.json

@@ -987,6 +987,10 @@
         "category": "Error",
         "code": 1344
     },
+    "An expression of type 'void' cannot be tested for truthiness": {
+        "category": "Error",
+        "code": 1345
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",

src/server/scriptInfo.ts

@@ -459,12 +459,15 @@ namespace ts.server {
             if (this.isDynamicOrHasMixedContent()) {
                 this.textStorage.reload("");
                 this.markContainingProjectsAsDirty();
+                return true;
             }
             else {
                 if (this.textStorage.reloadWithFileText(tempFileName)) {
                     this.markContainingProjectsAsDirty();
+                    return true;
                 }
             }
+            return false;
         }
 
         /*@internal*/

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -8114,7 +8114,7 @@ declare namespace ts.server {
         setOptions(formatSettings: FormatCodeSettings, preferences: UserPreferences | undefined): void;
         getLatestVersion(): string;
         saveTo(fileName: string): void;
-        reloadFromFile(tempFileName?: NormalizedPath): void;
+        reloadFromFile(tempFileName?: NormalizedPath): boolean;
         editContent(start: number, end: number, newText: string): void;
         markContainingProjectsAsDirty(): void;
         isOrphan(): boolean;

tests/baselines/reference/typePredicateInLoop.errors.txt

@@ -0,0 +1,27 @@
+tests/cases/compiler/typePredicateInLoop.ts(17,11): error TS1345: An expression of type 'void' cannot be tested for truthiness
+
+
+==== tests/cases/compiler/typePredicateInLoop.ts (1 errors) ====
+    // Repro from #12101
+    
+    interface Type {
+      type: number;
+    }
+    
+    interface TypeExt extends Type {
+      arr: Type[];
+    }
+    
+    const guard = (arg: Type): arg is TypeExt => arg.type === 1;
+    const otherFunc = (arg1: Type, arg2: TypeExt): void => {};
+    
+    export function y(arg: Type): void {
+      if (guard(arg)) {
+        for (const ITEM of arg.arr) {
+          if (otherFunc(ITEM, arg)) {
+              ~~~~~~~~~~~~~~~~~~~~
+!!! error TS1345: An expression of type 'void' cannot be tested for truthiness
+          }
+        }
+      }
+    }