moved SkSL BoolLiteral data into IRNode

Change-Id: I177b6daf4d6cb024ba20264ab01d0aa68e768a6d
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/319782
Reviewed-by: John Stiles <johnstiles@google.com>
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>

Author: Ethan Nicholas

src/sksl/SkSLByteCodeGenerator.cpp

@@ -901,7 +901,7 @@ bool ByteCodeGenerator::writeBinaryExpression(const BinaryExpression& b, bool di
 
 void ByteCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
     this->write(ByteCodeInstruction::kPushImmediate);
-    this->write32(b.fValue ? ~0 : 0);
+    this->write32(b.value() ? ~0 : 0);
 }
 
 void ByteCodeGenerator::writeConstructor(const Constructor& c) {

src/sksl/SkSLCFGGenerator.cpp

@@ -479,7 +479,7 @@ void CFGGenerator::addLValue(CFG& cfg, std::unique_ptr<Expression>* e) {
 }
 
 static bool is_true(Expression& expr) {
-    return expr.is<BoolLiteral>() && expr.as<BoolLiteral>().fValue;
+    return expr.is<BoolLiteral>() && expr.as<BoolLiteral>().value();
 }
 
 void CFGGenerator::addStatement(CFG& cfg, std::unique_ptr<Statement>* s) {

src/sksl/SkSLCompiler.cpp

@@ -881,7 +881,7 @@ void Compiler::simplifyExpression(DefinitionMap& definitions,
             if (t->fTest->kind() == Expression::Kind::kBoolLiteral) {
                 // ternary has a constant test, replace it with either the true or
                 // false branch
-                if (t->fTest->as<BoolLiteral>().fValue) {
+                if (t->fTest->as<BoolLiteral>().value()) {
                     (*iter)->setExpression(std::move(t->fIfTrue));
                 } else {
                     (*iter)->setExpression(std::move(t->fIfFalse));
@@ -1292,7 +1292,7 @@ void Compiler::simplifyStatement(DefinitionMap& definitions,
             IfStatement& i = stmt->as<IfStatement>();
             if (i.fTest->kind() == Expression::Kind::kBoolLiteral) {
                 // constant if, collapse down to a single branch
-                if (i.fTest->as<BoolLiteral>().fValue) {
+                if (i.fTest->as<BoolLiteral>().value()) {
                     SkASSERT(i.fIfTrue);
                     (*iter)->setStatement(std::move(i.fIfTrue));
                 } else {

src/sksl/SkSLDehydrator.cpp

@@ -267,7 +267,7 @@ void Dehydrator::write(const Expression* e) {
             case Expression::Kind::kBoolLiteral: {
                 const BoolLiteral& b = e->as<BoolLiteral>();
                 this->writeU8(Rehydrator::kBoolLiteral_Command);
-                this->writeU8(b.fValue);
+                this->writeU8(b.value());
                 break;
             }
             case Expression::Kind::kConstructor: {

src/sksl/SkSLGLSLCodeGenerator.cpp

@@ -1008,7 +1008,7 @@ void GLSLCodeGenerator::writePostfixExpression(const PostfixExpression& p,
 }
 
 void GLSLCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
-    this->write(b.fValue ? "true" : "false");
+    this->write(b.value() ? "true" : "false");
 }
 
 void GLSLCodeGenerator::writeIntLiteral(const IntLiteral& i) {

src/sksl/SkSLIRGenerator.cpp

@@ -532,7 +532,7 @@ std::unique_ptr<Statement> IRGenerator::convertIf(const ASTNode& n) {
     }
     if (test->kind() == Expression::Kind::kBoolLiteral) {
         // static boolean value, fold down to a single branch
-        if (test->as<BoolLiteral>().fValue) {
+        if (test->as<BoolLiteral>().value()) {
             return ifTrue;
         } else if (ifFalse) {
             return ifFalse;
@@ -1710,7 +1710,7 @@ static std::unique_ptr<Expression> short_circuit_boolean(const Context& context,
                                                          Token::Kind op,
                                                          const Expression& right) {
     SkASSERT(left.kind() == Expression::Kind::kBoolLiteral);
-    bool leftVal = left.as<BoolLiteral>().fValue;
+    bool leftVal = left.as<BoolLiteral>().value();
     if (op == Token::Kind::TK_LOGICALAND) {
         // (true && expr) -> (expr) and (false && expr) -> (false)
         return leftVal ? right.clone()
@@ -1753,8 +1753,8 @@ std::unique_ptr<Expression> IRGenerator::constantFold(const Expression& left,
     // types, which will let us be more intelligent about this.
     if (left.kind() == Expression::Kind::kBoolLiteral &&
         right.kind() == Expression::Kind::kBoolLiteral) {
-        bool leftVal  = left.as<BoolLiteral>().fValue;
-        bool rightVal = right.as<BoolLiteral>().fValue;
+        bool leftVal  = left.as<BoolLiteral>().value();
+        bool rightVal = right.as<BoolLiteral>().value();
         bool result;
         switch (op) {
             case Token::Kind::TK_LOGICALAND: result = leftVal && rightVal; break;
@@ -2013,7 +2013,7 @@ std::unique_ptr<Expression> IRGenerator::convertTernaryExpression(const ASTNode&
     }
     if (test->kind() == Expression::Kind::kBoolLiteral) {
         // static boolean test, just return one of the branches
-        if (test->as<BoolLiteral>().fValue) {
+        if (test->as<BoolLiteral>().value()) {
             return ifTrue;
         } else {
             return ifFalse;
@@ -2409,7 +2409,7 @@ std::unique_ptr<Expression> IRGenerator::convertPrefixExpression(const ASTNode&
             }
             if (base->kind() == Expression::Kind::kBoolLiteral) {
                 return std::make_unique<BoolLiteral>(fContext, base->fOffset,
-                                                     !base->as<BoolLiteral>().fValue);
+                                                     !base->as<BoolLiteral>().value());
             }
             break;
         case Token::Kind::TK_BITWISENOT:

src/sksl/SkSLMetalCodeGenerator.cpp

@@ -907,7 +907,7 @@ void MetalCodeGenerator::writePostfixExpression(const PostfixExpression& p,
 }
 
 void MetalCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
-    this->write(b.fValue ? "true" : "false");
+    this->write(b.value() ? "true" : "false");
 }
 
 void MetalCodeGenerator::writeIntLiteral(const IntLiteral& i) {

src/sksl/SkSLSPIRVCodeGenerator.cpp

@@ -2503,7 +2503,7 @@ SpvId SPIRVCodeGenerator::writePostfixExpression(const PostfixExpression& p, Out
 }
 
 SpvId SPIRVCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
-    if (b.fValue) {
+    if (b.value()) {
         if (fBoolTrue == 0) {
             fBoolTrue = this->nextId();
             this->writeInstruction(SpvOpConstantTrue, this->getType(b.type()), fBoolTrue,