Revert of added constant folding & branch elimination to skslc

src/sksl/SkSLIRGenerator.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #include "SkSLIRGenerator.h"
 
 #include "limits.h"
@@ skipping 228 matching lines @@
     if (!ifTrue) {
         return nullptr;
     }
     std::unique_ptr<Statement> ifFalse;
     if (s.fIfFalse) {
         ifFalse = this->convertStatement(*s.fIfFalse);
         if (!ifFalse) {
             return nullptr;
         }
     }
-    if (test->fKind == Expression::kBoolLiteral_Kind) {
-        // static boolean value, fold down to a single branch
-        if (((BoolLiteral&) *test).fValue) {
-            return ifTrue;
-        } else if (s.fIfFalse) {
-            return ifFalse;
-        } else {
-            // False & no else clause. Not an error, so don't return null!
-            return std::unique_ptr<Statement>(new Block(s.fPosition, { }, fSymbolTable));
-        }
-    }
     return std::unique_ptr<Statement>(new IfStatement(s.fPosition, std::move(test), 
                                                       std::move(ifTrue), std::move(ifFalse)));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertFor(const ASTForStatement& f) {
     AutoLoopLevel level(this);
     AutoSymbolTable table(this);
     std::unique_ptr<Statement> initializer;
     if (f.fInitializer) {
         initializer = this->convertStatement(*f.fInitializer);
@@ skipping 528 matching lines @@
         }
         return false;
     }
     if (tryFlipped) {
         return determine_binary_type(context, op, right, left, outRightType, outLeftType, 
                                      outResultType, false);
     }
     return false;
 }
 
-/**
- * If both operands are compile-time constants and can be folded, returns an expression representing
- * the folded value. Otherwise, returns null. Note that unlike most other functions here, null does
- * not represent a compilation error.
- */
-std::unique_ptr<Expression> IRGenerator::constantFold(const Expression& left,
-                                                      Token::Kind op,
-                                                      const Expression& right) {
-    // Note that we expressly do not worry about precision and overflow here -- we use the maximum
-    // precision to calculate the results and hope the result makes sense. The plan is to move the
-    // Skia caps into SkSL, so we have access to all of them including the precisions of the various
-    // types, which will let us be more intelligent about this.
-    if (left.fKind == Expression::kBoolLiteral_Kind && 
-        right.fKind == Expression::kBoolLiteral_Kind) {
-        bool leftVal  = ((BoolLiteral&) left).fValue;
-        bool rightVal = ((BoolLiteral&) right).fValue;
-        bool result;
-        switch (op) {
-            case Token::LOGICALAND: result = leftVal && rightVal; break;
-            case Token::LOGICALOR:  result = leftVal || rightVal; break;
-            case Token::LOGICALXOR: result = leftVal ^  rightVal; break;
-            default: return nullptr;
-        }
-        return std::unique_ptr<Expression>(new BoolLiteral(fContext, left.fPosition, result));
-    }
-    #define RESULT(t, op) std::unique_ptr<Expression>(new t ## Literal(fContext, left.fPosition, \
-                                                                       leftVal op rightVal))
-    if (left.fKind == Expression::kIntLiteral_Kind && right.fKind == Expression::kIntLiteral_Kind) {
-        int64_t leftVal  = ((IntLiteral&) left).fValue;
-        int64_t rightVal = ((IntLiteral&) right).fValue;
-        switch (op) {
-            case Token::PLUS:       return RESULT(Int,  +);
-            case Token::MINUS:      return RESULT(Int,  -);
-            case Token::STAR:       return RESULT(Int,  *);
-            case Token::SLASH:      return RESULT(Int,  /);
-            case Token::PERCENT:    return RESULT(Int,  %);
-            case Token::BITWISEAND: return RESULT(Int,  &);
-            case Token::BITWISEOR:  return RESULT(Int,  |);
-            case Token::BITWISEXOR: return RESULT(Int,  ^);
-            case Token::SHL:        return RESULT(Int,  <<);
-            case Token::SHR:        return RESULT(Int,  >>);
-            case Token::EQEQ:       return RESULT(Bool, ==);
-            case Token::NEQ:        return RESULT(Bool, !=);
-            case Token::GT:         return RESULT(Bool, >);
-            case Token::GTEQ:       return RESULT(Bool, >=);
-            case Token::LT:         return RESULT(Bool, <);
-            case Token::LTEQ:       return RESULT(Bool, <=);
-            default:                return nullptr;
-        }
-    }
-    if (left.fKind == Expression::kFloatLiteral_Kind && 
-        right.fKind == Expression::kFloatLiteral_Kind) {
-        double leftVal  = ((FloatLiteral&) left).fValue;
-        double rightVal = ((FloatLiteral&) right).fValue;
-        switch (op) {
-            case Token::PLUS:       return RESULT(Float, +);
-            case Token::MINUS:      return RESULT(Float, -);
-            case Token::STAR:       return RESULT(Float, *);
-            case Token::SLASH:      return RESULT(Float, /);
-            case Token::EQEQ:       return RESULT(Bool,  ==);
-            case Token::NEQ:        return RESULT(Bool,  !=);
-            case Token::GT:         return RESULT(Bool,  >);
-            case Token::GTEQ:       return RESULT(Bool,  >=);
-            case Token::LT:         return RESULT(Bool,  <);
-            case Token::LTEQ:       return RESULT(Bool,  <=);
-            default:                return nullptr;
-        }
-    }
-    #undef RESULT
-    return nullptr;
-}
-
 std::unique_ptr<Expression> IRGenerator::convertBinaryExpression(
                                                             const ASTBinaryExpression& expression) {
     std::unique_ptr<Expression> left = this->convertExpression(*expression.fLeft);
     if (!left) {
         return nullptr;
     }
     std::unique_ptr<Expression> right = this->convertExpression(*expression.fRight);
     if (!right) {
         return nullptr;
     }
     const Type* leftType;
     const Type* rightType;
     const Type* resultType;
     if (!determine_binary_type(fContext, expression.fOperator, left->fType, right->fType, &leftType,
                                &rightType, &resultType, !is_assignment(expression.fOperator))) {
         fErrors.error(expression.fPosition, "type mismatch: '" + 
                                             Token::OperatorName(expression.fOperator) + 
                                             "' cannot operate on '" + left->fType.fName + 
                                             "', '" + right->fType.fName + "'");
         return nullptr;
     }
     if (is_assignment(expression.fOperator)) {
         this->markWrittenTo(*left);
     }
     left = this->coerce(std::move(left), *leftType);
     right = this->coerce(std::move(right), *rightType);
     if (!left || !right) {
         return nullptr;
     }
-    std::unique_ptr<Expression> result = this->constantFold(*left.get(), expression.fOperator, 
-                                                            *right.get());
-    if (!result) {
-        result = std::unique_ptr<Expression>(new BinaryExpression(expression.fPosition,
-                                                                  std::move(left),
-                                                                  expression.fOperator,
-                                                                  std::move(right),
-                                                                  *resultType));
-    }
-    return result;
+    return std::unique_ptr<Expression>(new BinaryExpression(expression.fPosition, 
+                                                            std::move(left), 
+                                                            expression.fOperator, 
+                                                            std::move(right), 
+                                                            *resultType));
 }
 
 std::unique_ptr<Expression> IRGenerator::convertTernaryExpression(  
                                                            const ASTTernaryExpression& expression) {
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*expression.fTest), 
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
     }
     std::unique_ptr<Expression> ifTrue = this->convertExpression(*expression.fIfTrue);
@@ skipping 10 matching lines @@
     if (!determine_binary_type(fContext, Token::EQEQ, ifTrue->fType, ifFalse->fType, &trueType,
                                &falseType, &resultType, true)) {
         fErrors.error(expression.fPosition, "ternary operator result mismatch: '" + 
                                             ifTrue->fType.fName + "', '" + 
                                             ifFalse->fType.fName + "'");
         return nullptr;
     }
     ASSERT(trueType == falseType);
     ifTrue = this->coerce(std::move(ifTrue), *trueType);
     ifFalse = this->coerce(std::move(ifFalse), *falseType);
-    if (test->fKind == Expression::kBoolLiteral_Kind) {
-        // static boolean test, just return one of the branches
-        if (((BoolLiteral&) *test).fValue) {
-            return ifTrue;
-        } else {
-            return ifFalse;
-        }
-    }
     return std::unique_ptr<Expression>(new TernaryExpression(expression.fPosition, 
                                                              std::move(test),
                                                              std::move(ifTrue), 
                                                              std::move(ifFalse)));
 }
 
 std::unique_ptr<Expression> IRGenerator::call(Position position, 
                                               const FunctionDeclaration& function, 
                                               std::vector<std::unique_ptr<Expression>> arguments) {
     if (function.fParameters.size() != arguments.size()) {
@@ skipping 248 matching lines @@
             }
             this->markWrittenTo(*base);
             break;
         case Token::LOGICALNOT:
             if (base->fType != *fContext.fBool_Type) {
                 fErrors.error(expression.fPosition, 
                               "'" + Token::OperatorName(expression.fOperator) + 
                               "' cannot operate on '" + base->fType.description() + "'");
                 return nullptr;
             }
-            if (base->fKind == Expression::kBoolLiteral_Kind) {
-                return std::unique_ptr<Expression>(new BoolLiteral(fContext, base->fPosition,
-                                                                   !((BoolLiteral&) *base).fValue));
-            }
             break;
         case Token::BITWISENOT:
             if (base->fType != *fContext.fInt_Type) {
                 fErrors.error(expression.fPosition, 
                               "'" + Token::OperatorName(expression.fOperator) + 
                               "' cannot operate on '" + base->fType.description() + "'");
                 return nullptr;
             }
             break;
         default: 
@@ skipping 219 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }