diff --git a/src/sksl/SkSLByteCodeGenerator.cpp b/src/sksl/SkSLByteCodeGenerator.cpp
index 8a63b2b..5907ade 100644
--- a/src/sksl/SkSLByteCodeGenerator.cpp
+++ b/src/sksl/SkSLByteCodeGenerator.cpp
@@ -901,7 +901,7 @@
 
 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) {
diff --git a/src/sksl/SkSLCFGGenerator.cpp b/src/sksl/SkSLCFGGenerator.cpp
index 316b68d..377ad8e 100644
--- a/src/sksl/SkSLCFGGenerator.cpp
+++ b/src/sksl/SkSLCFGGenerator.cpp
@@ -479,7 +479,7 @@
 }
 
 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) {
diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp
index 8a50681..44ca904 100644
--- a/src/sksl/SkSLCompiler.cpp
+++ b/src/sksl/SkSLCompiler.cpp
@@ -881,7 +881,7 @@
             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 @@
             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 {
diff --git a/src/sksl/SkSLDehydrator.cpp b/src/sksl/SkSLDehydrator.cpp
index 683346d..a6883c1 100644
--- a/src/sksl/SkSLDehydrator.cpp
+++ b/src/sksl/SkSLDehydrator.cpp
@@ -267,7 +267,7 @@
             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: {
diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp
index 81b9d5b..b6103fd 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.cpp
+++ b/src/sksl/SkSLGLSLCodeGenerator.cpp
@@ -1008,7 +1008,7 @@
 }
 
 void GLSLCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
-    this->write(b.fValue ? "true" : "false");
+    this->write(b.value() ? "true" : "false");
 }
 
 void GLSLCodeGenerator::writeIntLiteral(const IntLiteral& i) {
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
index 68802c8..f1f5ad7 100644
--- a/src/sksl/SkSLIRGenerator.cpp
+++ b/src/sksl/SkSLIRGenerator.cpp
@@ -532,7 +532,7 @@
     }
     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 @@
                                                          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 @@
     // 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 @@
     }
     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 @@
             }
             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:
diff --git a/src/sksl/SkSLMetalCodeGenerator.cpp b/src/sksl/SkSLMetalCodeGenerator.cpp
index db75ce7..335ff10 100644
--- a/src/sksl/SkSLMetalCodeGenerator.cpp
+++ b/src/sksl/SkSLMetalCodeGenerator.cpp
@@ -907,7 +907,7 @@
 }
 
 void MetalCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
-    this->write(b.fValue ? "true" : "false");
+    this->write(b.value() ? "true" : "false");
 }
 
 void MetalCodeGenerator::writeIntLiteral(const IntLiteral& i) {
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp
index 6610b9f..c23fc8e 100644
--- a/src/sksl/SkSLSPIRVCodeGenerator.cpp
+++ b/src/sksl/SkSLSPIRVCodeGenerator.cpp
@@ -2503,7 +2503,7 @@
 }
 
 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,
diff --git a/src/sksl/SkSLTestRehydrator.cpp b/src/sksl/SkSLTestRehydrator.cpp
new file mode 100644
index 0000000..21c57bc
--- /dev/null
+++ b/src/sksl/SkSLTestRehydrator.cpp
@@ -0,0 +1,340 @@
+/*
+ * 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 <fstream>
+#include "src/sksl/SkSLCompiler.h"
+#include "src/sksl/SkSLDehydrator.h"
+#include "src/sksl/SkSLFileOutputStream.h"
+#include "src/sksl/SkSLIRGenerator.h"
+#include "src/sksl/SkSLStringStream.h"
+#include "src/sksl/SkSLUtil.h"
+#include "src/sksl/ir/SkSLEnum.h"
+#include "src/sksl/ir/SkSLUnresolvedFunction.h"
+
+// Given the path to a file (e.g. src/gpu/effects/GrFooFragmentProcessor.fp) and the expected
+// filename prefix and suffix (e.g. "Gr" and ".fp"), returns the "base name" of the
+// file (in this case, 'FooFragmentProcessor'). If no match, returns the empty string.
+static SkSL::String base_name(const char* fpPath, const char* prefix, const char* suffix) {
+    SkSL::String result;
+    const char* end = fpPath + strlen(fpPath);
+    const char* fileName = end;
+    // back up until we find a slash
+    while (fileName != fpPath && '/' != *(fileName - 1) && '\\' != *(fileName - 1)) {
+        --fileName;
+    }
+    if (!strncmp(fileName, prefix, strlen(prefix)) &&
+        !strncmp(end - strlen(suffix), suffix, strlen(suffix))) {
+        result.append(fileName + strlen(prefix), end - fileName - strlen(prefix) - strlen(suffix));
+    }
+    return result;
+}
+
+// Given a string containing an SkSL program, searches for a #pragma settings comment, like so:
+//    /*#pragma settings Default Sharpen*/
+// The passed-in Settings object will be updated accordingly. Any number of options can be provided.
+static void detect_shader_settings(const SkSL::String& text, SkSL::Program::Settings* settings) {
+    using Factory = SkSL::ShaderCapsFactory;
+
+    // Find a matching comment and isolate the name portion.
+    static constexpr char kPragmaSettings[] = "/*#pragma settings ";
+    const char* settingsPtr = strstr(text.c_str(), kPragmaSettings);
+    if (settingsPtr != nullptr) {
+        // Subtract one here in order to preserve the leading space, which is necessary to allow
+        // consumeSuffix to find the first item.
+        settingsPtr += strlen(kPragmaSettings) - 1;
+
+        const char* settingsEnd = strstr(settingsPtr, "*/");
+        if (settingsEnd != nullptr) {
+            SkSL::String settingsText{settingsPtr, size_t(settingsEnd - settingsPtr)};
+
+            // Apply settings as requested. Since they can come in any order, repeat until we've
+            // consumed them all.
+            for (;;) {
+                const size_t startingLength = settingsText.length();
+
+                if (settingsText.consumeSuffix(" AddAndTrueToLoopCondition")) {
+                    static auto s_addAndTrueCaps = Factory::AddAndTrueToLoopCondition();
+                    settings->fCaps = s_addAndTrueCaps.get();
+                }
+                if (settingsText.consumeSuffix(" CannotUseFractForNegativeValues")) {
+                    static auto s_negativeFractCaps = Factory::CannotUseFractForNegativeValues();
+                    settings->fCaps = s_negativeFractCaps.get();
+                }
+                if (settingsText.consumeSuffix(" CannotUseFragCoord")) {
+                    static auto s_noFragCoordCaps = Factory::CannotUseFragCoord();
+                    settings->fCaps = s_noFragCoordCaps.get();
+                }
+                if (settingsText.consumeSuffix(" CannotUseMinAndAbsTogether")) {
+                    static auto s_minAbsCaps = Factory::CannotUseMinAndAbsTogether();
+                    settings->fCaps = s_minAbsCaps.get();
+                }
+                if (settingsText.consumeSuffix(" Default")) {
+                    static auto s_defaultCaps = Factory::Default();
+                    settings->fCaps = s_defaultCaps.get();
+                }
+                if (settingsText.consumeSuffix(" EmulateAbsIntFunction")) {
+                    static auto s_emulateAbsIntCaps = Factory::EmulateAbsIntFunction();
+                    settings->fCaps = s_emulateAbsIntCaps.get();
+                }
+                if (settingsText.consumeSuffix(" FragCoordsOld")) {
+                    static auto s_fragCoordsOld = Factory::FragCoordsOld();
+                    settings->fCaps = s_fragCoordsOld.get();
+                }
+                if (settingsText.consumeSuffix(" FragCoordsNew")) {
+                    static auto s_fragCoordsNew = Factory::FragCoordsNew();
+                    settings->fCaps = s_fragCoordsNew.get();
+                }
+                if (settingsText.consumeSuffix(" GeometryShaderExtensionString")) {
+                    static auto s_geometryExtCaps = Factory::GeometryShaderExtensionString();
+                    settings->fCaps = s_geometryExtCaps.get();
+                }
+                if (settingsText.consumeSuffix(" GeometryShaderSupport")) {
+                    static auto s_geometryShaderCaps = Factory::GeometryShaderSupport();
+                    settings->fCaps = s_geometryShaderCaps.get();
+                }
+                if (settingsText.consumeSuffix(" GSInvocationsExtensionString")) {
+                    static auto s_gsInvocationCaps = Factory::GSInvocationsExtensionString();
+                    settings->fCaps = s_gsInvocationCaps.get();
+                }
+                if (settingsText.consumeSuffix(" IncompleteShortIntPrecision")) {
+                    static auto s_incompleteShortIntCaps = Factory::IncompleteShortIntPrecision();
+                    settings->fCaps = s_incompleteShortIntCaps.get();
+                }
+                if (settingsText.consumeSuffix(" MustForceNegatedAtanParamToFloat")) {
+                    static auto s_negativeAtanCaps = Factory::MustForceNegatedAtanParamToFloat();
+                    settings->fCaps = s_negativeAtanCaps.get();
+                }
+                if (settingsText.consumeSuffix(" NoGSInvocationsSupport")) {
+                    static auto s_noGSInvocations = Factory::NoGSInvocationsSupport();
+                    settings->fCaps = s_noGSInvocations.get();
+                }
+                if (settingsText.consumeSuffix(" RemovePowWithConstantExponent")) {
+                    static auto s_powCaps = Factory::RemovePowWithConstantExponent();
+                    settings->fCaps = s_powCaps.get();
+                }
+                if (settingsText.consumeSuffix(" RewriteDoWhileLoops")) {
+                    static auto s_rewriteLoopCaps = Factory::RewriteDoWhileLoops();
+                    settings->fCaps = s_rewriteLoopCaps.get();
+                }
+                if (settingsText.consumeSuffix(" ShaderDerivativeExtensionString")) {
+                    static auto s_derivativeCaps = Factory::ShaderDerivativeExtensionString();
+                    settings->fCaps = s_derivativeCaps.get();
+                }
+                if (settingsText.consumeSuffix(" UnfoldShortCircuitAsTernary")) {
+                    static auto s_ternaryCaps = Factory::UnfoldShortCircuitAsTernary();
+                    settings->fCaps = s_ternaryCaps.get();
+                }
+                if (settingsText.consumeSuffix(" UsesPrecisionModifiers")) {
+                    static auto s_precisionCaps = Factory::UsesPrecisionModifiers();
+                    settings->fCaps = s_precisionCaps.get();
+                }
+                if (settingsText.consumeSuffix(" Version110")) {
+                    static auto s_version110Caps = Factory::Version110();
+                    settings->fCaps = s_version110Caps.get();
+                }
+                if (settingsText.consumeSuffix(" Version450Core")) {
+                    static auto s_version450CoreCaps = Factory::Version450Core();
+                    settings->fCaps = s_version450CoreCaps.get();
+                }
+                if (settingsText.consumeSuffix(" FlipY")) {
+                    settings->fFlipY = true;
+                }
+                if (settingsText.consumeSuffix(" ForceHighPrecision")) {
+                    settings->fForceHighPrecision = true;
+                }
+                if (settingsText.consumeSuffix(" Sharpen")) {
+                    settings->fSharpenTextures = true;
+                }
+
+                if (settingsText.empty()) {
+                    break;
+                }
+                if (settingsText.length() == startingLength) {
+                    printf("Unrecognized #pragma settings: %s\n", settingsText.c_str());
+                    exit(3);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Very simple standalone executable to facilitate testing.
+ */
+int main(int argc, const char** argv) {
+    bool honorSettings = true;
+    if (argc == 4) {
+        if (0 == strcmp(argv[3], "--settings")) {
+            honorSettings = true;
+        } else if (0 == strcmp(argv[3], "--nosettings")) {
+            honorSettings = false;
+        } else {
+            printf("unrecognized flag: %s\n", argv[3]);
+            exit(1);
+        }
+    } else if (argc != 3) {
+        printf("usage: skslc <input> <output> <flags>\n"
+               "\n"
+               "Allowed flags:\n"
+               "--settings:   honor embedded /*#pragma settings*/ comments.\n"
+               "--nosettings: ignore /*#pragma settings*/ comments\n");
+        exit(1);
+    }
+
+    SkSL::Program::Kind kind;
+    SkSL::String input(argv[1]);
+    if (input.endsWith(".vert")) {
+        kind = SkSL::Program::kVertex_Kind;
+    } else if (input.endsWith(".frag") || input.endsWith(".sksl")) {
+        kind = SkSL::Program::kFragment_Kind;
+    } else if (input.endsWith(".geom")) {
+        kind = SkSL::Program::kGeometry_Kind;
+    } else if (input.endsWith(".fp")) {
+        kind = SkSL::Program::kFragmentProcessor_Kind;
+    } else if (input.endsWith(".stage")) {
+        kind = SkSL::Program::kPipelineStage_Kind;
+    } else {
+        printf("input filename must end in '.vert', '.frag', '.geom', '.fp', '.stage', or "
+               "'.sksl'\n");
+        exit(1);
+    }
+
+    std::ifstream in(argv[1]);
+    SkSL::String text((std::istreambuf_iterator<char>(in)),
+                       std::istreambuf_iterator<char>());
+    if (in.rdstate()) {
+        printf("error reading '%s'\n", argv[1]);
+        exit(2);
+    }
+
+    SkSL::Program::Settings settings;
+    if (honorSettings) {
+        detect_shader_settings(text, &settings);
+    }
+    SkSL::String name(argv[2]);
+    if (name.endsWith(".spirv")) {
+        SkSL::FileOutputStream out(argv[2]);
+        SkSL::Compiler compiler;
+        if (!out.isValid()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+        std::unique_ptr<SkSL::Program> program = compiler.convertProgram(kind, text, settings);
+        if (!program || !compiler.toSPIRV(*program, out)) {
+            printf("%s", compiler.errorText().c_str());
+            exit(3);
+        }
+        if (!out.close()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+    } else if (name.endsWith(".glsl")) {
+        SkSL::FileOutputStream out(argv[2]);
+        SkSL::Compiler compiler;
+        if (!out.isValid()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+        std::unique_ptr<SkSL::Program> program = compiler.convertProgram(kind, text, settings);
+        if (!program || !compiler.toGLSL(*program, out)) {
+            printf("%s", compiler.errorText().c_str());
+            exit(3);
+        }
+        if (!out.close()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+    } else if (name.endsWith(".metal")) {
+        SkSL::FileOutputStream out(argv[2]);
+        SkSL::Compiler compiler;
+        if (!out.isValid()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+        std::unique_ptr<SkSL::Program> program = compiler.convertProgram(kind, text, settings);
+        if (!program || !compiler.toMetal(*program, out)) {
+            printf("%s", compiler.errorText().c_str());
+            exit(3);
+        }
+        if (!out.close()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+    } else if (name.endsWith(".h")) {
+        SkSL::FileOutputStream out(argv[2]);
+        SkSL::Compiler compiler(SkSL::Compiler::kPermitInvalidStaticTests_Flag);
+        if (!out.isValid()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+        settings.fReplaceSettings = false;
+        std::unique_ptr<SkSL::Program> program = compiler.convertProgram(kind, text, settings);
+        if (!program || !compiler.toH(*program, base_name(argv[1], "Gr", ".fp"), out)) {
+            printf("%s", compiler.errorText().c_str());
+            exit(3);
+        }
+        if (!out.close()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+    } else if (name.endsWith(".cpp")) {
+        SkSL::FileOutputStream out(argv[2]);
+        SkSL::Compiler compiler(SkSL::Compiler::kPermitInvalidStaticTests_Flag);
+        if (!out.isValid()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+        settings.fReplaceSettings = false;
+        std::unique_ptr<SkSL::Program> program = compiler.convertProgram(kind, text, settings);
+        if (!program || !compiler.toCPP(*program, base_name(argv[1], "Gr", ".fp"), out)) {
+            printf("%s", compiler.errorText().c_str());
+            exit(3);
+        }
+        if (!out.close()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+    } else if (name.endsWith(".dehydrated.sksl")) {
+        SkSL::FileOutputStream out(argv[2]);
+        SkSL::Compiler compiler;
+        if (!out.isValid()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+        std::shared_ptr<SkSL::SymbolTable> symbols;
+        std::vector<std::unique_ptr<SkSL::ProgramElement>> elements;
+        compiler.processIncludeFile(kind, argv[1], nullptr, &elements, &symbols);
+        SkSL::Dehydrator dehydrator;
+        for (int i = symbols->fParent->fOwnedSymbols.size() - 1; i >= 0; --i) {
+            symbols->fOwnedSymbols.insert(symbols->fOwnedSymbols.begin(),
+                                          std::move(symbols->fParent->fOwnedSymbols[i]));
+        }
+        for (const auto& p : *symbols->fParent) {
+            symbols->addWithoutOwnership(p.first, p.second);
+        }
+        dehydrator.write(*symbols);
+        dehydrator.write(elements);
+        SkSL::String baseName = base_name(argv[1], "", ".sksl");
+        SkSL::StringStream buffer;
+        dehydrator.finish(buffer);
+        const SkSL::String& data = buffer.str();
+        out.printf("static constexpr size_t SKSL_INCLUDE_%s_LENGTH = %d;\n", baseName.c_str(),
+                   (int) data.length());
+        out.printf("static uint8_t SKSL_INCLUDE_%s[%d] = {", baseName.c_str(), (int) data.length());
+        for (size_t i = 0; i < data.length(); ++i) {
+            out.printf("%d,", (uint8_t) data[i]);
+        }
+        out.printf("};\n");
+        if (!out.close()) {
+            printf("error writing '%s'\n", argv[2]);
+            exit(4);
+        }
+    } else {
+        printf("expected output filename to end with '.spirv', '.glsl', '.cpp', '.h', or '.metal'");
+        exit(1);
+    }
+}
diff --git a/src/sksl/ir/SkSLBoolLiteral.h b/src/sksl/ir/SkSLBoolLiteral.h
index c82014e..437872e 100644
--- a/src/sksl/ir/SkSLBoolLiteral.h
+++ b/src/sksl/ir/SkSLBoolLiteral.h
@@ -16,15 +16,19 @@
 /**
  * Represents 'true' or 'false'.
  */
-struct BoolLiteral : public Expression {
+class BoolLiteral : public Expression {
+public:
     static constexpr Kind kExpressionKind = Kind::kBoolLiteral;
 
     BoolLiteral(const Context& context, int offset, bool value)
-    : INHERITED(offset, kExpressionKind, context.fBool_Type.get())
-    , fValue(value) {}
+    : INHERITED(offset, kExpressionKind, BoolLiteralData{context.fBool_Type.get(), value}) {}
+
+    bool value() const {
+        return this->boolLiteralData().fValue;
+    }
 
     String description() const override {
-        return String(fValue ? "true" : "false");
+        return String(this->value() ? "true" : "false");
     }
 
     bool hasProperty(Property property) const override {
@@ -36,22 +40,19 @@
     }
 
     bool compareConstant(const Context& context, const Expression& other) const override {
-        BoolLiteral& b = (BoolLiteral&) other;
-        return fValue == b.fValue;
+        const BoolLiteral& b = other.as<BoolLiteral>();
+        return this->value() == b.value();
     }
 
     std::unique_ptr<Expression> clone() const override {
-        return std::unique_ptr<Expression>(new BoolLiteral(fOffset, fValue, &this->type()));
+        return std::unique_ptr<Expression>(new BoolLiteral(fOffset, this->value(), &this->type()));
     }
 
-    const bool fValue;
-
-    using INHERITED = Expression;
-
 private:
     BoolLiteral(int offset, bool value, const Type* type)
-    : INHERITED(offset, kExpressionKind, type)
-    , fValue(value) {}
+    : INHERITED(offset, kExpressionKind, BoolLiteralData{type, value}) {}
+
+    using INHERITED = Expression;
 };
 
 }  // namespace SkSL
diff --git a/src/sksl/ir/SkSLExpression.h b/src/sksl/ir/SkSLExpression.h
index fc5d506..8beb8ed 100644
--- a/src/sksl/ir/SkSLExpression.h
+++ b/src/sksl/ir/SkSLExpression.h
@@ -56,6 +56,11 @@
         kContainsRTAdjust
     };
 
+    Expression(int offset, Kind kind, BoolLiteralData data)
+        : INHERITED(offset, (int) kind, data) {
+        SkASSERT(kind >= Kind::kFirst && kind <= Kind::kLast);
+    }
+
     Expression(int offset, Kind kind, const Type* type)
         : INHERITED(offset, (int) kind, type) {
         SkASSERT(kind >= Kind::kFirst && kind <= Kind::kLast);
diff --git a/src/sksl/ir/SkSLIRNode.cpp b/src/sksl/ir/SkSLIRNode.cpp
index e4de26f..38492da 100644
--- a/src/sksl/ir/SkSLIRNode.cpp
+++ b/src/sksl/ir/SkSLIRNode.cpp
@@ -11,18 +11,25 @@
 
 namespace SkSL {
 
-IRNode::IRNode(int offset, int kind, BlockData data, std::vector<std::unique_ptr<Statement>> stmts)
+IRNode::IRNode(int offset, int kind, const BlockData& data,
+               std::vector<std::unique_ptr<Statement>> stmts)
 : fOffset(offset)
 , fKind(kind)
 , fData(data)
 , fStatementChildren(std::move(stmts)) {}
 
+IRNode::IRNode(int offset, int kind, const BoolLiteralData& data)
+: fOffset(offset)
+, fKind(kind)
+, fData(data) {}
+
+
 IRNode::IRNode(int offset, int kind, const Type* data)
 : fOffset(offset)
 , fKind(kind)
 , fData(data) {}
 
-IRNode::IRNode(int offset, int kind, TypeTokenData data)
+IRNode::IRNode(int offset, int kind, const TypeTokenData& data)
 : fOffset(offset)
 , fKind(kind)
 , fData(data) {}
diff --git a/src/sksl/ir/SkSLIRNode.h b/src/sksl/ir/SkSLIRNode.h
index 4892463..c340fee 100644
--- a/src/sksl/ir/SkSLIRNode.h
+++ b/src/sksl/ir/SkSLIRNode.h
@@ -50,6 +50,8 @@
 
     const Type& type() const {
         switch (fData.fKind) {
+            case NodeData::Kind::kBoolLiteral:
+                return *this->boolLiteralData().fType;
             case NodeData::Kind::kType:
                 return *this->typeData();
             case NodeData::Kind::kTypeToken:
@@ -68,6 +70,11 @@
         bool fIsScope;
     };
 
+    struct BoolLiteralData {
+        const Type* fType;
+        bool fValue;
+    };
+
     struct TypeTokenData {
         const Type* fType;
         Token::Kind fToken;
@@ -75,45 +82,64 @@
 
     struct NodeData {
         char fBytes[std::max({sizeof(BlockData),
+                              sizeof(BoolLiteralData),
                               sizeof(Type*),
                               sizeof(TypeTokenData)})];
 
         enum class Kind {
             kBlock,
+            kBoolLiteral,
             kType,
             kTypeToken,
         } fKind;
 
         NodeData() = default;
 
-        NodeData(BlockData data)
+        NodeData(const BlockData& data)
             : fKind(Kind::kBlock) {
-            new(reinterpret_cast<BlockData*>(fBytes)) BlockData{std::move(data.fSymbolTable),
-                                                                data.fIsScope};
+            *(new(fBytes) BlockData) = data;
+        }
+
+        NodeData(const BoolLiteralData& data)
+            : fKind(Kind::kBoolLiteral) {
+            *(new(fBytes) BoolLiteralData) = data;
         }
 
         NodeData(const Type* data)
             : fKind(Kind::kType) {
-            memcpy(fBytes, &data, sizeof(data));
+            *(new(fBytes) const Type*) = data;
         }
 
-        NodeData(TypeTokenData data)
+        NodeData(const TypeTokenData& data)
             : fKind(Kind::kTypeToken) {
-            memcpy(fBytes, &data, sizeof(data));
+            *(new(fBytes) TypeTokenData) = data;
         }
 
         ~NodeData() {
-            if (fKind == Kind::kBlock) {
-                reinterpret_cast<BlockData*>(fBytes)->~BlockData();
+            switch (fKind) {
+                case Kind::kBlock:
+                    reinterpret_cast<BlockData*>(fBytes)->~BlockData();
+                    break;
+                case Kind::kBoolLiteral:
+                    reinterpret_cast<BoolLiteralData*>(fBytes)->~BoolLiteralData();
+                    break;
+                case Kind::kType:
+                    break;
+                case Kind::kTypeToken:
+                    reinterpret_cast<TypeTokenData*>(fBytes)->~TypeTokenData();
+                    break;
             }
         }
     };
 
-    IRNode(int offset, int kind, BlockData data, std::vector<std::unique_ptr<Statement>> stmts);
+    IRNode(int offset, int kind, const BlockData& data,
+           std::vector<std::unique_ptr<Statement>> stmts);
+
+    IRNode(int offset, int kind, const BoolLiteralData& data);
 
     IRNode(int offset, int kind, const Type* data = nullptr);
 
-    IRNode(int offset, int kind, TypeTokenData data);
+    IRNode(int offset, int kind, const TypeTokenData& data);
 
     IRNode(const IRNode& other);
 
@@ -166,6 +192,11 @@
         return *reinterpret_cast<const BlockData*>(fData.fBytes);
     }
 
+    const BoolLiteralData& boolLiteralData() const {
+        SkASSERT(fData.fKind == NodeData::Kind::kBoolLiteral);
+        return *reinterpret_cast<const BoolLiteralData*>(fData.fBytes);
+    }
+
     const Type* typeData() const {
         SkASSERT(fData.fKind == NodeData::Kind::kType);
         return *reinterpret_cast<const Type* const*>(fData.fBytes);