fix: simplify && and || when the LHS is constant

To fix #2946, we can precompute the LHS and
allow one of the existing optimizations to
generate an `if` that gets precomputed later.

Still, for slightly more complicated cases, like
`123 && 456`, that alone doesn't seem to work. So
we add an additional optimization to check the
truthiness of the LHS and use that to simplify the
expression to either the LHS or the RHS, without
generating an `if`.

Author: CountBleck

src/compiler.ts

@@ -4574,16 +4574,30 @@ export class Compiler extends DiagnosticEmitter {
           }
           leftExpr = this.convertExpression(leftExpr, leftType, commonType, false, left);
           leftType = commonType;
+
+          // This is sometimes needed to make the left trivial
+          let leftPrecompExpr = module.runExpression(leftExpr, ExpressionRunnerFlags.PreserveSideeffects);
+          if (leftPrecompExpr) leftExpr = leftPrecompExpr;
+
           rightExpr = this.convertExpression(rightExpr, rightType, commonType, false, right);
           rightType = commonType;
 
           // simplify if copying left is trivial
           if (expr = module.tryCopyTrivialExpression(leftExpr)) {
-            expr = module.if(
-              this.makeIsTrueish(leftExpr, this.currentType, left),
-              rightExpr,
-              expr
-            );
+            let condExpr = this.makeIsTrueish(leftExpr, this.currentType, left);
+            let condKind = this.evaluateCondition(condExpr);
+
+            if (condKind == ConditionKind.Unknown) {
+              expr = module.if(
+                condExpr,
+                rightExpr,
+                expr
+              );
+            } else {
+              expr = condKind == ConditionKind.True
+                ? rightExpr
+                : expr;
+            }
 
           // if not possible, tee left to a temp
           } else {
@@ -4654,16 +4668,30 @@ export class Compiler extends DiagnosticEmitter {
           let possiblyNull = leftType.is(TypeFlags.Nullable) && rightType.is(TypeFlags.Nullable);
           leftExpr = this.convertExpression(leftExpr, leftType, commonType, false, left);
           leftType = commonType;
+
+          // This is sometimes needed to make the left trivial
+          let leftPrecompExpr = module.runExpression(leftExpr, ExpressionRunnerFlags.PreserveSideeffects);
+          if (leftPrecompExpr) leftExpr = leftPrecompExpr;
+
           rightExpr = this.convertExpression(rightExpr, rightType, commonType, false, right);
           rightType = commonType;
 
           // simplify if copying left is trivial
           if (expr = module.tryCopyTrivialExpression(leftExpr)) {
-            expr = module.if(
-              this.makeIsTrueish(leftExpr, leftType, left),
-              expr,
-              rightExpr
-            );
+            let condExpr = this.makeIsTrueish(leftExpr, this.currentType, left);
+            let condKind = this.evaluateCondition(condExpr);
+
+            if (condKind == ConditionKind.Unknown) {
+              expr = module.if(
+                condExpr,
+                expr,
+                rightExpr
+              );
+            } else {
+              expr = condKind == ConditionKind.True
+                ? expr
+                : rightExpr;
+            }
 
           // if not possible, tee left to a temp. local
           } else {