diff --git a/src/sksl/SkSLCFGGenerator.cpp b/src/sksl/SkSLCFGGenerator.cpp
index e2c0380..6438d59 100644
--- a/src/sksl/SkSLCFGGenerator.cpp
+++ b/src/sksl/SkSLCFGGenerator.cpp
@@ -56,7 +56,7 @@
         const char* separator = "";
         for (auto iter = fBlocks[i].fBefore.begin(); iter != fBlocks[i].fBefore.end(); iter++) {
             printf("%s%s = %s", separator, iter->first->description().c_str(),
-                   *iter->second ? (*iter->second)->description().c_str() : "<undefined>");
+                   iter->second ? (*iter->second)->description().c_str() : "<undefined>");
             separator = ", ";
         }
         printf("\nEntrances: ");
@@ -68,9 +68,9 @@
         printf("\n");
         for (size_t j = 0; j < fBlocks[i].fNodes.size(); j++) {
             BasicBlock::Node& n = fBlocks[i].fNodes[j];
-            printf("Node %d: %s\n", (int) j, n.fKind == BasicBlock::Node::kExpression_Kind
-                                                           ? (*n.fExpression)->description().c_str()
-                                                           : n.fStatement->description().c_str());
+            printf("Node %d (%p): %s\n", (int) j, &n, n.fKind == BasicBlock::Node::kExpression_Kind
+                                                         ? (*n.expression())->description().c_str()
+                                                         : (*n.statement())->description().c_str());
         }
         printf("Exits: ");
         separator = "";
@@ -82,6 +82,207 @@
     }
 }
 
+bool BasicBlock::tryRemoveExpressionBefore(std::vector<BasicBlock::Node>::iterator* iter,
+                                           Expression* e) {
+    if (e->fKind == Expression::kTernary_Kind) {
+        return false;
+    }
+    bool result;
+    if ((*iter)->fKind == BasicBlock::Node::kExpression_Kind) {
+        ASSERT((*iter)->expression()->get() != e);
+        Expression* old = (*iter)->expression()->get();
+        do {
+            if ((*iter) == fNodes.begin()) {
+                ABORT("couldn't find %s before %s\n", e->description().c_str(),
+                                                      old->description().c_str());
+            }
+            --(*iter);
+        } while ((*iter)->fKind != BasicBlock::Node::kExpression_Kind ||
+                 (*iter)->expression()->get() != e);
+        result = this->tryRemoveExpression(iter);
+        while ((*iter)->fKind != BasicBlock::Node::kExpression_Kind ||
+               (*iter)->expression()->get() != old) {
+            ASSERT(*iter != fNodes.end());
+            ++(*iter);
+        }
+    } else {
+        Statement* old = (*iter)->statement()->get();
+        do {
+            if ((*iter) == fNodes.begin()) {
+                ABORT("couldn't find %s before %s\n", e->description().c_str(),
+                                                      old->description().c_str());
+            }
+            --(*iter);
+        } while ((*iter)->fKind != BasicBlock::Node::kExpression_Kind ||
+                 (*iter)->expression()->get() != e);
+        result = this->tryRemoveExpression(iter);
+        while ((*iter)->fKind != BasicBlock::Node::kStatement_Kind ||
+               (*iter)->statement()->get() != old) {
+            ASSERT(*iter != fNodes.end());
+            ++(*iter);
+        }
+    }
+    return result;
+}
+
+bool BasicBlock::tryRemoveLValueBefore(std::vector<BasicBlock::Node>::iterator* iter,
+                                       Expression* lvalue) {
+    switch (lvalue->fKind) {
+        case Expression::kVariableReference_Kind:
+            return true;
+        case Expression::kSwizzle_Kind:
+            return this->tryRemoveLValueBefore(iter, ((Swizzle*) lvalue)->fBase.get());
+        case Expression::kFieldAccess_Kind:
+            return this->tryRemoveLValueBefore(iter, ((FieldAccess*) lvalue)->fBase.get());
+        case Expression::kIndex_Kind:
+            if (!this->tryRemoveLValueBefore(iter, ((IndexExpression*) lvalue)->fBase.get())) {
+                return false;
+            }
+            return this->tryRemoveExpressionBefore(iter, ((IndexExpression*) lvalue)->fIndex.get());
+        default:
+            ABORT("invalid lvalue: %s\n", lvalue->description().c_str());
+    }
+}
+
+bool BasicBlock::tryRemoveExpression(std::vector<BasicBlock::Node>::iterator* iter) {
+    Expression* expr = (*iter)->expression()->get();
+    switch (expr->fKind) {
+        case Expression::kBinary_Kind: {
+            BinaryExpression* b = (BinaryExpression*) expr;
+            if (b->fOperator == Token::EQ) {
+                if (!this->tryRemoveLValueBefore(iter, b->fLeft.get())) {
+                    return false;
+                }
+            } else if (!this->tryRemoveExpressionBefore(iter, b->fLeft.get())) {
+                return false;
+            }
+            if (!this->tryRemoveExpressionBefore(iter, b->fRight.get())) {
+                return false;
+            }
+            ASSERT((*iter)->expression()->get() == expr);
+            *iter = fNodes.erase(*iter);
+            return true;
+        }
+        case Expression::kTernary_Kind: {
+            // ternaries cross basic block boundaries, must regenerate the CFG to remove it
+            return false;
+        }
+        case Expression::kFieldAccess_Kind: {
+            FieldAccess* f = (FieldAccess*) expr;
+            if (!this->tryRemoveExpressionBefore(iter, f->fBase.get())) {
+                return false;
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        }
+        case Expression::kSwizzle_Kind: {
+            Swizzle* s = (Swizzle*) expr;
+            if (!this->tryRemoveExpressionBefore(iter, s->fBase.get())) {
+                return false;
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        }
+        case Expression::kIndex_Kind: {
+            IndexExpression* idx = (IndexExpression*) expr;
+            if (!this->tryRemoveExpressionBefore(iter, idx->fBase.get())) {
+                return false;
+            }
+            if (!this->tryRemoveExpressionBefore(iter, idx->fIndex.get())) {
+                return false;
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        }
+        case Expression::kConstructor_Kind: {
+            Constructor* c = (Constructor*) expr;
+            for (auto& arg : c->fArguments) {
+                if (!this->tryRemoveExpressionBefore(iter, arg.get())) {
+                    return false;
+                }
+                ASSERT((*iter)->expression()->get() == expr);
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        }
+        case Expression::kFunctionCall_Kind: {
+            FunctionCall* f = (FunctionCall*) expr;
+            for (auto& arg : f->fArguments) {
+                if (!this->tryRemoveExpressionBefore(iter, arg.get())) {
+                    return false;
+                }
+                ASSERT((*iter)->expression()->get() == expr);
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        }
+        case Expression::kPrefix_Kind:
+            if (!this->tryRemoveExpressionBefore(iter,
+                                                 ((PrefixExpression*) expr)->fOperand.get())) {
+                return false;
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        case Expression::kPostfix_Kind:
+            if (!this->tryRemoveExpressionBefore(iter,
+                                                 ((PrefixExpression*) expr)->fOperand.get())) {
+                return false;
+            }
+            *iter = fNodes.erase(*iter);
+            return true;
+        case Expression::kBoolLiteral_Kind:  // fall through
+        case Expression::kFloatLiteral_Kind: // fall through
+        case Expression::kIntLiteral_Kind:   // fall through
+        case Expression::kVariableReference_Kind:
+            *iter = fNodes.erase(*iter);
+            return true;
+        default:
+            ABORT("unhandled expression: %s\n", expr->description().c_str());
+    }
+}
+
+bool BasicBlock::tryInsertExpression(std::vector<BasicBlock::Node>::iterator* iter,
+                                     std::unique_ptr<Expression>* expr) {
+    switch ((*expr)->fKind) {
+        case Expression::kBinary_Kind: {
+            BinaryExpression* b = (BinaryExpression*) expr->get();
+            if (!this->tryInsertExpression(iter, &b->fRight)) {
+                return false;
+            }
+            ++(*iter);
+            if (!this->tryInsertExpression(iter, &b->fLeft)) {
+                return false;
+            }
+            ++(*iter);
+            BasicBlock::Node node = { BasicBlock::Node::kExpression_Kind, true, expr, nullptr };
+            *iter = fNodes.insert(*iter, node);
+            return true;
+        }
+        case Expression::kBoolLiteral_Kind:  // fall through
+        case Expression::kFloatLiteral_Kind: // fall through
+        case Expression::kIntLiteral_Kind:   // fall through
+        case Expression::kVariableReference_Kind: {
+            BasicBlock::Node node = { BasicBlock::Node::kExpression_Kind, true, expr, nullptr };
+            *iter = fNodes.insert(*iter, node);
+            return true;
+        }
+        case Expression::kConstructor_Kind: {
+            Constructor* c = (Constructor*) expr->get();
+            for (auto& arg : c->fArguments) {
+                if (!this->tryInsertExpression(iter, &arg)) {
+                    return false;
+                }
+                ++(*iter);
+            }
+            BasicBlock::Node node = { BasicBlock::Node::kExpression_Kind, true, expr, nullptr };
+            *iter = fNodes.insert(*iter, node);
+            return true;
+        }
+        default:
+            return false;
+    }
+}
+
 void CFGGenerator::addExpression(CFG& cfg, std::unique_ptr<Expression>* e, bool constantPropagate) {
     ASSERT(e);
     switch ((*e)->fKind) {
@@ -182,6 +383,8 @@
         case Expression::kTernary_Kind: {
             TernaryExpression* t = (TernaryExpression*) e->get();
             this->addExpression(cfg, &t->fTest, constantPropagate);
+            cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kExpression_Kind,
+                                                         constantPropagate, e, nullptr });
             BlockId start = cfg.fCurrent;
             cfg.newBlock();
             this->addExpression(cfg, &t->fIfTrue, constantPropagate);
@@ -223,24 +426,26 @@
     }
 }
 
-void CFGGenerator::addStatement(CFG& cfg, const Statement* s) {
-    switch (s->fKind) {
+void CFGGenerator::addStatement(CFG& cfg, std::unique_ptr<Statement>* s) {
+    switch ((*s)->fKind) {
         case Statement::kBlock_Kind:
-            for (const auto& child : ((const Block*) s)->fStatements) {
-                addStatement(cfg, child.get());
+            for (auto& child : ((Block&) **s).fStatements) {
+                addStatement(cfg, &child);
             }
             break;
         case Statement::kIf_Kind: {
-            IfStatement* ifs = (IfStatement*) s;
-            this->addExpression(cfg, &ifs->fTest, true);
+            IfStatement& ifs = (IfStatement&) **s;
+            this->addExpression(cfg, &ifs.fTest, true);
+            cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, false,
+                                                         nullptr, s });
             BlockId start = cfg.fCurrent;
             cfg.newBlock();
-            this->addStatement(cfg, ifs->fIfTrue.get());
+            this->addStatement(cfg, &ifs.fIfTrue);
             BlockId next = cfg.newBlock();
-            if (ifs->fIfFalse) {
+            if (ifs.fIfFalse) {
                 cfg.fCurrent = start;
                 cfg.newBlock();
-                this->addStatement(cfg, ifs->fIfFalse.get());
+                this->addStatement(cfg, &ifs.fIfFalse);
                 cfg.addExit(cfg.fCurrent, next);
                 cfg.fCurrent = next;
             } else {
@@ -249,14 +454,16 @@
             break;
         }
         case Statement::kExpression_Kind: {
-            this->addExpression(cfg, &((ExpressionStatement&) *s).fExpression, true);
+            this->addExpression(cfg, &((ExpressionStatement&) **s).fExpression, true);
+            cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, false,
+                                                         nullptr, s });
             break;
         }
         case Statement::kVarDeclarations_Kind: {
-            VarDeclarationsStatement& decls = ((VarDeclarationsStatement&) *s);
+            VarDeclarationsStatement& decls = ((VarDeclarationsStatement&) **s);
             for (auto& vd : decls.fDeclaration->fVars) {
-                if (vd.fValue) {
-                    this->addExpression(cfg, &vd.fValue, true);
+                if (vd->fValue) {
+                    this->addExpression(cfg, &vd->fValue, true);
                 }
             }
             cfg.fBlocks[cfg.fCurrent].fNodes.push_back({ BasicBlock::Node::kStatement_Kind, false,
@@ -269,7 +476,7 @@
             cfg.fCurrent = cfg.newIsolatedBlock();
             break;
         case Statement::kReturn_Kind: {
-            ReturnStatement& r = ((ReturnStatement&) *s);
+            ReturnStatement& r = ((ReturnStatement&) **s);
             if (r.fExpression) {
                 this->addExpression(cfg, &r.fExpression, true);
             }
@@ -291,16 +498,16 @@
             cfg.fCurrent = cfg.newIsolatedBlock();
             break;
         case Statement::kWhile_Kind: {
-            WhileStatement* w = (WhileStatement*) s;
+            WhileStatement& w = (WhileStatement&) **s;
             BlockId loopStart = cfg.newBlock();
             fLoopContinues.push(loopStart);
             BlockId loopExit = cfg.newIsolatedBlock();
             fLoopExits.push(loopExit);
-            this->addExpression(cfg, &w->fTest, true);
+            this->addExpression(cfg, &w.fTest, true);
             BlockId test = cfg.fCurrent;
             cfg.addExit(test, loopExit);
             cfg.newBlock();
-            this->addStatement(cfg, w->fStatement.get());
+            this->addStatement(cfg, &w.fStatement);
             cfg.addExit(cfg.fCurrent, loopStart);
             fLoopContinues.pop();
             fLoopExits.pop();
@@ -308,13 +515,13 @@
             break;
         }
         case Statement::kDo_Kind: {
-            DoStatement* d = (DoStatement*) s;
+            DoStatement& d = (DoStatement&) **s;
             BlockId loopStart = cfg.newBlock();
             fLoopContinues.push(loopStart);
             BlockId loopExit = cfg.newIsolatedBlock();
             fLoopExits.push(loopExit);
-            this->addStatement(cfg, d->fStatement.get());
-            this->addExpression(cfg, &d->fTest, true);
+            this->addStatement(cfg, &d.fStatement);
+            this->addExpression(cfg, &d.fTest, true);
             cfg.addExit(cfg.fCurrent, loopExit);
             cfg.addExit(cfg.fCurrent, loopStart);
             fLoopContinues.pop();
@@ -323,26 +530,26 @@
             break;
         }
         case Statement::kFor_Kind: {
-            ForStatement* f = (ForStatement*) s;
-            if (f->fInitializer) {
-                this->addStatement(cfg, f->fInitializer.get());
+            ForStatement& f = (ForStatement&) **s;
+            if (f.fInitializer) {
+                this->addStatement(cfg, &f.fInitializer);
             }
             BlockId loopStart = cfg.newBlock();
             BlockId next = cfg.newIsolatedBlock();
             fLoopContinues.push(next);
             BlockId loopExit = cfg.newIsolatedBlock();
             fLoopExits.push(loopExit);
-            if (f->fTest) {
-                this->addExpression(cfg, &f->fTest, true);
+            if (f.fTest) {
+                this->addExpression(cfg, &f.fTest, true);
                 BlockId test = cfg.fCurrent;
                 cfg.addExit(test, loopExit);
             }
             cfg.newBlock();
-            this->addStatement(cfg, f->fStatement.get());
+            this->addStatement(cfg, &f.fStatement);
             cfg.addExit(cfg.fCurrent, next);
             cfg.fCurrent = next;
-            if (f->fNext) {
-                this->addExpression(cfg, &f->fNext, true);
+            if (f.fNext) {
+                this->addExpression(cfg, &f.fNext, true);
             }
             cfg.addExit(cfg.fCurrent, loopStart);
             fLoopContinues.pop();
@@ -351,12 +558,12 @@
             break;
         }
         case Statement::kSwitch_Kind: {
-            SwitchStatement* ss = (SwitchStatement*) s;
-            this->addExpression(cfg, &ss->fValue, true);
+            SwitchStatement& ss = (SwitchStatement&) **s;
+            this->addExpression(cfg, &ss.fValue, true);
             BlockId start = cfg.fCurrent;
             BlockId switchExit = cfg.newIsolatedBlock();
             fLoopExits.push(switchExit);
-            for (const auto& c : ss->fCases) {
+            for (const auto& c : ss.fCases) {
                 cfg.newBlock();
                 cfg.addExit(start, cfg.fCurrent);
                 if (c->fValue) {
@@ -364,13 +571,13 @@
                     // because it must be constant. Not worth running two loops for.
                     this->addExpression(cfg, &c->fValue, true);
                 }
-                for (const auto& caseStatement : c->fStatements) {
-                    this->addStatement(cfg, caseStatement.get());
+                for (auto& caseStatement : c->fStatements) {
+                    this->addStatement(cfg, &caseStatement);
                 }
             }
             cfg.addExit(cfg.fCurrent, switchExit);
             // note that unlike GLSL, our grammar requires the default case to be last
-            if (0 == ss->fCases.size() || ss->fCases[ss->fCases.size() - 1]->fValue) {
+            if (0 == ss.fCases.size() || ss.fCases[ss.fCases.size() - 1]->fValue) {
                 // switch does not have a default clause, mark that it can skip straight to the end
                 cfg.addExit(start, switchExit);
             }
@@ -378,17 +585,19 @@
             cfg.fCurrent = switchExit;
             break;
         }
+        case Statement::kNop_Kind:
+            break;
         default:
-            printf("statement: %s\n", s->description().c_str());
+            printf("statement: %s\n", (*s)->description().c_str());
             ABORT("unsupported statement kind");
     }
 }
 
-CFG CFGGenerator::getCFG(const FunctionDefinition& f) {
+CFG CFGGenerator::getCFG(FunctionDefinition& f) {
     CFG result;
     result.fStart = result.newBlock();
     result.fCurrent = result.fStart;
-    this->addStatement(result, f.fBody.get());
+    this->addStatement(result, &f.fBody);
     result.newBlock();
     result.fExit = result.fCurrent;
     return result;
diff --git a/src/sksl/SkSLCFGGenerator.h b/src/sksl/SkSLCFGGenerator.h
index 0a03d69..885d926 100644
--- a/src/sksl/SkSLCFGGenerator.h
+++ b/src/sksl/SkSLCFGGenerator.h
@@ -26,6 +26,42 @@
             kExpression_Kind
         };
 
+        Node(Kind kind, bool constantPropagation, std::unique_ptr<Expression>* expression,
+             std::unique_ptr<Statement>* statement)
+        : fKind(kind)
+        , fConstantPropagation(constantPropagation)
+        , fExpression(expression)
+        , fStatement(statement) {}
+
+        std::unique_ptr<Expression>* expression() const {
+            ASSERT(fKind == kExpression_Kind);
+            return fExpression;
+        }
+
+        void setExpression(std::unique_ptr<Expression> expr) {
+            ASSERT(fKind == kExpression_Kind);
+            *fExpression = std::move(expr);
+        }
+
+        std::unique_ptr<Statement>* statement() const {
+            ASSERT(fKind == kStatement_Kind);
+            return fStatement;
+        }
+
+        void setStatement(std::unique_ptr<Statement> stmt) {
+            ASSERT(fKind == kStatement_Kind);
+            *fStatement = std::move(stmt);
+        }
+
+        String description() const {
+            if (fKind == kStatement_Kind) {
+                return (*fStatement)->description();
+            } else {
+                ASSERT(fKind == kExpression_Kind);
+                return (*fExpression)->description();
+            }
+        }
+
         Kind fKind;
         // if false, this node should not be subject to constant propagation. This happens with
         // compound assignment (i.e. x *= 2), in which the value x is used as an rvalue for
@@ -35,10 +71,45 @@
         // assignment if the target is constant (i.e. x = 1; x *= 2; should become x = 1; x = 1 * 2;
         // and then collapse down to a simple x = 2;).
         bool fConstantPropagation;
+
+    private:
+        // we store pointers to the unique_ptrs so that we can replace expressions or statements
+        // during optimization without having to regenerate the entire tree
         std::unique_ptr<Expression>* fExpression;
-        const Statement* fStatement;
+        std::unique_ptr<Statement>* fStatement;
     };
 
+    /**
+     * Attempts to remove the expression (and its subexpressions) pointed to by the iterator. If the
+     * expression can be cleanly removed, returns true and updates the iterator to point to the
+     * expression after the deleted expression. Otherwise returns false (and the CFG will need to be
+     * regenerated).
+     */
+    bool tryRemoveExpression(std::vector<BasicBlock::Node>::iterator* iter);
+
+    /**
+     * Locates and attempts remove an expression occurring before the expression pointed to by iter.
+     * If the expression can be cleanly removed, returns true and resets iter to a valid iterator
+     * pointing to the same expression it did initially. Otherwise returns false (and the CFG will
+     * need to be regenerated).
+     */
+    bool tryRemoveExpressionBefore(std::vector<BasicBlock::Node>::iterator* iter, Expression* e);
+
+    /**
+     * As tryRemoveExpressionBefore, but for lvalues. As lvalues are at most partially evaluated
+     * (for instance, x[i] = 0 evaluates i but not x) this will only look for the parts of the
+     * lvalue that are actually evaluated.
+     */
+    bool tryRemoveLValueBefore(std::vector<BasicBlock::Node>::iterator* iter, Expression* lvalue);
+
+    /**
+     * Attempts to inserts a new expression before the node pointed to by iter. If the
+     * expression can be cleanly inserted, returns true and updates the iterator to point to the
+     * newly inserted expression. Otherwise returns false (and the CFG will need to be regenerated).
+     */
+    bool tryInsertExpression(std::vector<BasicBlock::Node>::iterator* iter,
+                             std::unique_ptr<Expression>* expr);
+
     std::vector<Node> fNodes;
     std::set<BlockId> fEntrances;
     std::set<BlockId> fExits;
@@ -81,10 +152,10 @@
 public:
     CFGGenerator() {}
 
-    CFG getCFG(const FunctionDefinition& f);
+    CFG getCFG(FunctionDefinition& f);
 
 private:
-    void addStatement(CFG& cfg, const Statement* s);
+    void addStatement(CFG& cfg, std::unique_ptr<Statement>* s);
 
     void addExpression(CFG& cfg, std::unique_ptr<Expression>* e, bool constantPropagate);
 
diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp
index ea87e99..e4ab700 100644
--- a/src/sksl/SkSLCompiler.cpp
+++ b/src/sksl/SkSLCompiler.cpp
@@ -14,9 +14,12 @@
 #include "SkSLParser.h"
 #include "SkSLSPIRVCodeGenerator.h"
 #include "ir/SkSLExpression.h"
+#include "ir/SkSLExpressionStatement.h"
 #include "ir/SkSLIntLiteral.h"
 #include "ir/SkSLModifiersDeclaration.h"
+#include "ir/SkSLNop.h"
 #include "ir/SkSLSymbolTable.h"
+#include "ir/SkSLTernaryExpression.h"
 #include "ir/SkSLUnresolvedFunction.h"
 #include "ir/SkSLVarDeclarations.h"
 
@@ -207,8 +210,8 @@
                               DefinitionMap* definitions) {
     switch (node.fKind) {
         case BasicBlock::Node::kExpression_Kind: {
-            ASSERT(node.fExpression);
-            const Expression* expr = (Expression*) node.fExpression->get();
+            ASSERT(node.expression());
+            const Expression* expr = (Expression*) node.expression()->get();
             switch (expr->fKind) {
                 case Expression::kBinary_Kind: {
                     BinaryExpression* b = (BinaryExpression*) expr;
@@ -240,22 +243,30 @@
                                        p->fOperand.get(),
                                        (std::unique_ptr<Expression>*) &fContext.fDefined_Expression,
                                        definitions);
-
                     }
                     break;
                 }
+                case Expression::kVariableReference_Kind: {
+                    const VariableReference* v = (VariableReference*) expr;
+                    if (v->fRefKind != VariableReference::kRead_RefKind) {
+                        this->addDefinition(
+                                       v,
+                                       (std::unique_ptr<Expression>*) &fContext.fDefined_Expression,
+                                       definitions);
+                    }
+                }
                 default:
                     break;
             }
             break;
         }
         case BasicBlock::Node::kStatement_Kind: {
-            const Statement* stmt = (Statement*) node.fStatement;
+            const Statement* stmt = (Statement*) node.statement()->get();
             if (stmt->fKind == Statement::kVarDeclarations_Kind) {
                 VarDeclarationsStatement* vd = (VarDeclarationsStatement*) stmt;
-                for (VarDeclaration& decl : vd->fDeclaration->fVars) {
-                    if (decl.fValue) {
-                        (*definitions)[decl.fVar] = &decl.fValue;
+                for (const auto& decl : vd->fDeclaration->fVars) {
+                    if (decl->fValue) {
+                        (*definitions)[decl->fVar] = &decl->fValue;
                     }
                 }
             }
@@ -308,12 +319,12 @@
     for (const auto& block : cfg.fBlocks) {
         for (const auto& node : block.fNodes) {
             if (node.fKind == BasicBlock::Node::kStatement_Kind) {
-                ASSERT(node.fStatement);
-                const Statement* s = node.fStatement;
+                ASSERT(node.statement());
+                const Statement* s = node.statement()->get();
                 if (s->fKind == Statement::kVarDeclarations_Kind) {
                     const VarDeclarationsStatement* vd = (const VarDeclarationsStatement*) s;
-                    for (const VarDeclaration& decl : vd->fDeclaration->fVars) {
-                        result[decl.fVar] = nullptr;
+                    for (const auto& decl : vd->fDeclaration->fVars) {
+                        result[decl->fVar] = nullptr;
                     }
                 }
             }
@@ -322,20 +333,290 @@
     return result;
 }
 
-void Compiler::scanCFG(const FunctionDefinition& f) {
-    CFG cfg = CFGGenerator().getCFG(f);
+/**
+ * Returns true if assigning to this lvalue has no effect.
+ */
+static bool is_dead(const Expression& lvalue) {
+    switch (lvalue.fKind) {
+        case Expression::kVariableReference_Kind:
+            return ((VariableReference&) lvalue).fVariable.dead();
+        case Expression::kSwizzle_Kind:
+            return is_dead(*((Swizzle&) lvalue).fBase);
+        case Expression::kFieldAccess_Kind:
+            return is_dead(*((FieldAccess&) lvalue).fBase);
+        case Expression::kIndex_Kind: {
+            const IndexExpression& idx = (IndexExpression&) lvalue;
+            return is_dead(*idx.fBase) && !idx.fIndex->hasSideEffects();
+        }
+        default:
+            ABORT("invalid lvalue: %s\n", lvalue.description().c_str());
+    }
+}
 
-    // compute the data flow
-    cfg.fBlocks[cfg.fStart].fBefore = compute_start_state(cfg);
+/**
+ * Returns true if this is an assignment which can be collapsed down to just the right hand side due
+ * to a dead target and lack of side effects on the left hand side.
+ */
+static bool dead_assignment(const BinaryExpression& b) {
+    if (!Token::IsAssignment(b.fOperator)) {
+        return false;
+    }
+    return is_dead(*b.fLeft);
+}
+
+void Compiler::computeDataFlow(CFG* cfg) {
+    cfg->fBlocks[cfg->fStart].fBefore = compute_start_state(*cfg);
     std::set<BlockId> workList;
-    for (BlockId i = 0; i < cfg.fBlocks.size(); i++) {
+    for (BlockId i = 0; i < cfg->fBlocks.size(); i++) {
         workList.insert(i);
     }
     while (workList.size()) {
         BlockId next = *workList.begin();
         workList.erase(workList.begin());
-        this->scanCFG(&cfg, next, &workList);
+        this->scanCFG(cfg, next, &workList);
     }
+}
+
+/**
+ * Attempts to replace the expression pointed to by iter with a new one (in both the CFG and the
+ * IR). If the expression can be cleanly removed, returns true and updates the iterator to point to
+ * the newly-inserted element. Otherwise updates only the IR and returns false (and the CFG will
+ * need to be regenerated).
+ */
+bool try_replace_expression(BasicBlock* b,
+                            std::vector<BasicBlock::Node>::iterator* iter,
+                            std::unique_ptr<Expression>* newExpression) {
+    std::unique_ptr<Expression>* target = (*iter)->expression();
+    if (!b->tryRemoveExpression(iter)) {
+        *target = std::move(*newExpression);
+        return false;
+    }
+    *target = std::move(*newExpression);
+    return b->tryInsertExpression(iter, target);
+}
+
+/**
+ * Returns true if the expression is a constant numeric literal with the specified value.
+ */
+bool is_constant(Expression& expr, double value) {
+    switch (expr.fKind) {
+        case Expression::kIntLiteral_Kind:
+            return ((IntLiteral&) expr).fValue == value;
+        case Expression::kFloatLiteral_Kind:
+            return ((FloatLiteral&) expr).fValue == value;
+        default:
+            return false;
+    }
+}
+
+/**
+ * Collapses the binary expression pointed to by iter down to just the right side (in both the IR
+ * and CFG structures).
+ */
+void delete_left(BasicBlock* b,
+                 std::vector<BasicBlock::Node>::iterator* iter,
+                 bool* outUpdated,
+                 bool* outNeedsRescan) {
+    *outUpdated = true;
+    if (!try_replace_expression(b, iter, &((BinaryExpression&) **(*iter)->expression()).fRight)) {
+        *outNeedsRescan = true;
+    }
+}
+
+/**
+ * Collapses the binary expression pointed to by iter down to just the left side (in both the IR and
+ * CFG structures).
+ */
+void delete_right(BasicBlock* b,
+                  std::vector<BasicBlock::Node>::iterator* iter,
+                  bool* outUpdated,
+                  bool* outNeedsRescan) {
+    *outUpdated = true;
+    if (!try_replace_expression(b, iter, &((BinaryExpression&) **(*iter)->expression()).fLeft)) {
+        *outNeedsRescan = true;
+    }
+}
+
+void Compiler::simplifyExpression(DefinitionMap& definitions,
+                                  BasicBlock& b,
+                                  std::vector<BasicBlock::Node>::iterator* iter,
+                                  std::unordered_set<const Variable*>* undefinedVariables,
+                                  bool* outUpdated,
+                                  bool* outNeedsRescan) {
+    Expression* expr = (*iter)->expression()->get();
+    ASSERT(expr);
+    if ((*iter)->fConstantPropagation) {
+        std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator, definitions);
+        if (optimized) {
+            if (!try_replace_expression(&b, iter, &optimized)) {
+                *outNeedsRescan = true;
+            }
+            ASSERT((*iter)->fKind == BasicBlock::Node::kExpression_Kind);
+            expr = (*iter)->expression()->get();
+            *outUpdated = true;
+        }
+    }
+    switch (expr->fKind) {
+        case Expression::kVariableReference_Kind: {
+            const Variable& var = ((VariableReference*) expr)->fVariable;
+            if (var.fStorage == Variable::kLocal_Storage && !definitions[&var] &&
+                (*undefinedVariables).find(&var) == (*undefinedVariables).end()) {
+                (*undefinedVariables).insert(&var);
+                this->error(expr->fPosition,
+                            "'" + var.fName + "' has not been assigned");
+            }
+            break;
+        }
+        case Expression::kTernary_Kind: {
+            TernaryExpression* t = (TernaryExpression*) expr;
+            if (t->fTest->fKind == Expression::kBoolLiteral_Kind) {
+                // ternary has a constant test, replace it with either the true or
+                // false branch
+                if (((BoolLiteral&) *t->fTest).fValue) {
+                    (*iter)->setExpression(std::move(t->fIfTrue));
+                } else {
+                    (*iter)->setExpression(std::move(t->fIfFalse));
+                }
+                *outUpdated = true;
+                *outNeedsRescan = true;
+            }
+            break;
+        }
+        case Expression::kBinary_Kind: {
+            // collapse useless expressions like x * 1 or x + 0
+            BinaryExpression* bin = (BinaryExpression*) expr;
+            switch (bin->fOperator) {
+                case Token::STAR:
+                    if (is_constant(*bin->fLeft, 1)) {
+                        delete_left(&b, iter, outUpdated, outNeedsRescan);
+                    }
+                    else if (is_constant(*bin->fRight, 1)) {
+                        delete_right(&b, iter, outUpdated, outNeedsRescan);
+                    }
+                    break;
+                case Token::PLUS: // fall through
+                case Token::MINUS:
+                    if (is_constant(*bin->fLeft, 0)) {
+                        delete_left(&b, iter, outUpdated, outNeedsRescan);
+                    }
+                    else if (is_constant(*bin->fRight, 0)) {
+                        delete_right(&b, iter, outUpdated, outNeedsRescan);
+                    }
+                    break;
+                case Token::SLASH:
+                    if (is_constant(*bin->fRight, 1)) {
+                        delete_right(&b, iter, outUpdated, outNeedsRescan);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        default:
+            break;
+    }
+}
+
+void Compiler::simplifyStatement(DefinitionMap& definitions,
+                                  BasicBlock& b,
+                                  std::vector<BasicBlock::Node>::iterator* iter,
+                                  std::unordered_set<const Variable*>* undefinedVariables,
+                                  bool* outUpdated,
+                                  bool* outNeedsRescan) {
+    Statement* stmt = (*iter)->statement()->get();
+    switch (stmt->fKind) {
+        case Statement::kVarDeclarations_Kind: {
+            VarDeclarations& vd = *((VarDeclarationsStatement&) *stmt).fDeclaration;
+            for (auto varIter = vd.fVars.begin(); varIter != vd.fVars.end(); ) {
+                const auto& varDecl = **varIter;
+                if (varDecl.fVar->dead() &&
+                    (!varDecl.fValue ||
+                     !varDecl.fValue->hasSideEffects())) {
+                    if (varDecl.fValue) {
+                        ASSERT((*iter)->statement()->get() == stmt);
+                        if (!b.tryRemoveExpressionBefore(iter, varDecl.fValue.get())) {
+                            *outNeedsRescan = true;
+                        }
+                    }
+                    varIter = vd.fVars.erase(varIter);
+                    *outUpdated = true;
+                } else {
+                    ++varIter;
+                }
+            }
+            if (vd.fVars.size() == 0) {
+                (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
+            }
+            break;
+        }
+        case Statement::kIf_Kind: {
+            IfStatement& i = (IfStatement&) *stmt;
+            if (i.fIfFalse && i.fIfFalse->isEmpty()) {
+                // else block doesn't do anything, remove it
+                i.fIfFalse.reset();
+                *outUpdated = true;
+                *outNeedsRescan = true;
+            }
+            if (!i.fIfFalse && i.fIfTrue->isEmpty()) {
+                // if block doesn't do anything, no else block
+                if (i.fTest->hasSideEffects()) {
+                    // test has side effects, keep it
+                    (*iter)->setStatement(std::unique_ptr<Statement>(
+                                                      new ExpressionStatement(std::move(i.fTest))));
+                } else {
+                    // no if, no else, no test side effects, kill the whole if
+                    // statement
+                    (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
+                }
+                *outUpdated = true;
+                *outNeedsRescan = true;
+            }
+            break;
+        }
+        case Statement::kExpression_Kind: {
+            ExpressionStatement& e = (ExpressionStatement&) *stmt;
+            ASSERT((*iter)->statement()->get() == &e);
+            if (e.fExpression->fKind == Expression::kBinary_Kind) {
+                BinaryExpression& bin = (BinaryExpression&) *e.fExpression;
+                if (dead_assignment(bin)) {
+                    if (!b.tryRemoveExpressionBefore(iter, &bin)) {
+                        *outNeedsRescan = true;
+                    }
+                    if (bin.fRight->hasSideEffects()) {
+                        // still have to evaluate the right due to side effects,
+                        // replace the binary expression with just the right side
+                        e.fExpression = std::move(bin.fRight);
+                        if (!b.tryInsertExpression(iter, &e.fExpression)) {
+                            *outNeedsRescan = true;
+                        }
+                    } else {
+                        // no side effects, kill the whole statement
+                        ASSERT((*iter)->statement()->get() == stmt);
+                        (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
+                    }
+                    *outUpdated = true;
+                    break;
+                }
+            }
+            if (!e.fExpression->hasSideEffects()) {
+                // Expression statement with no side effects, kill it
+                if (!b.tryRemoveExpressionBefore(iter, e.fExpression.get())) {
+                    *outNeedsRescan = true;
+                }
+                ASSERT((*iter)->statement()->get() == stmt);
+                (*iter)->setStatement(std::unique_ptr<Statement>(new Nop()));
+                *outUpdated = true;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+void Compiler::scanCFG(FunctionDefinition& f) {
+    CFG cfg = CFGGenerator().getCFG(f);
+    this->computeDataFlow(&cfg);
 
     // check for unreachable code
     for (size_t i = 0; i < cfg.fBlocks.size(); i++) {
@@ -344,10 +625,10 @@
             Position p;
             switch (cfg.fBlocks[i].fNodes[0].fKind) {
                 case BasicBlock::Node::kStatement_Kind:
-                    p = cfg.fBlocks[i].fNodes[0].fStatement->fPosition;
+                    p = (*cfg.fBlocks[i].fNodes[0].statement())->fPosition;
                     break;
                 case BasicBlock::Node::kExpression_Kind:
-                    p = (*cfg.fBlocks[i].fNodes[0].fExpression)->fPosition;
+                    p = (*cfg.fBlocks[i].fNodes[0].expression())->fPosition;
                     break;
             }
             this->error(p, String("unreachable"));
@@ -357,33 +638,34 @@
         return;
     }
 
-    // check for undefined variables, perform constant propagation
-    for (BasicBlock& b : cfg.fBlocks) {
-        DefinitionMap definitions = b.fBefore;
-        for (BasicBlock::Node& n : b.fNodes) {
-            if (n.fKind == BasicBlock::Node::kExpression_Kind) {
-                ASSERT(n.fExpression);
-                Expression* expr = n.fExpression->get();
-                if (n.fConstantPropagation) {
-                    std::unique_ptr<Expression> optimized = expr->constantPropagate(*fIRGenerator,
-                                                                                    definitions);
-                    if (optimized) {
-                        n.fExpression->reset(optimized.release());
-                        expr = n.fExpression->get();
-                    }
-                }
-                if (expr->fKind == Expression::kVariableReference_Kind) {
-                    const Variable& var = ((VariableReference*) expr)->fVariable;
-                    if (var.fStorage == Variable::kLocal_Storage &&
-                        !definitions[&var]) {
-                        this->error(expr->fPosition,
-                                    "'" + var.fName + "' has not been assigned");
-                    }
-                }
-            }
-            this->addDefinitions(n, &definitions);
+    // check for dead code & undefined variables, perform constant propagation
+    std::unordered_set<const Variable*> undefinedVariables;
+    bool updated;
+    bool needsRescan = false;
+    do {
+        if (needsRescan) {
+            cfg = CFGGenerator().getCFG(f);
+            this->computeDataFlow(&cfg);
+            needsRescan = false;
         }
-    }
+
+        updated = false;
+        for (BasicBlock& b : cfg.fBlocks) {
+            DefinitionMap definitions = b.fBefore;
+
+            for (auto iter = b.fNodes.begin(); iter != b.fNodes.end() && !needsRescan; ++iter) {
+                if (iter->fKind == BasicBlock::Node::kExpression_Kind) {
+                    this->simplifyExpression(definitions, b, &iter, &undefinedVariables, &updated,
+                                             &needsRescan);
+                } else {
+                    this->simplifyStatement(definitions, b, &iter, &undefinedVariables, &updated,
+                                             &needsRescan);
+                }
+                this->addDefinitions(*iter, &definitions);
+            }
+        }
+    } while (updated);
+    ASSERT(!needsRescan);
 
     // check for missing return
     if (f.fDeclaration.fReturnType != *fContext.fVoid_Type) {
diff --git a/src/sksl/SkSLCompiler.h b/src/sksl/SkSLCompiler.h
index 7e3c83e..5e7bc9e 100644
--- a/src/sksl/SkSLCompiler.h
+++ b/src/sksl/SkSLCompiler.h
@@ -9,6 +9,7 @@
 #define SKSL_COMPILER
 
 #include <set>
+#include <unordered_set>
 #include <vector>
 #include "ir/SkSLProgram.h"
 #include "ir/SkSLSymbolTable.h"
@@ -71,7 +72,31 @@
 
     void scanCFG(CFG* cfg, BlockId block, std::set<BlockId>* workList);
 
-    void scanCFG(const FunctionDefinition& f);
+    void computeDataFlow(CFG* cfg);
+
+    /**
+     * Simplifies the expression pointed to by iter (in both the IR and CFG structures), if
+     * possible.
+     */
+    void simplifyExpression(DefinitionMap& definitions,
+                            BasicBlock& b,
+                            std::vector<BasicBlock::Node>::iterator* iter,
+                            std::unordered_set<const Variable*>* undefinedVariables,
+                            bool* outUpdated,
+                            bool* outNeedsRescan);
+
+    /**
+     * Simplifies the statement pointed to by iter (in both the IR and CFG structures), if
+     * possible.
+     */
+    void simplifyStatement(DefinitionMap& definitions,
+                           BasicBlock& b,
+                           std::vector<BasicBlock::Node>::iterator* iter,
+                           std::unordered_set<const Variable*>* undefinedVariables,
+                           bool* outUpdated,
+                           bool* outNeedsRescan);
+
+    void scanCFG(FunctionDefinition& f);
 
     void internalConvertProgram(String text,
                                 Modifiers::Flag* defaultPrecision,
diff --git a/src/sksl/SkSLContext.h b/src/sksl/SkSLContext.h
index 450baa5..a9ebe9d 100644
--- a/src/sksl/SkSLContext.h
+++ b/src/sksl/SkSLContext.h
@@ -283,6 +283,10 @@
         virtual String description() const override {
             return String("<defined>");
         }
+        
+        bool hasSideEffects() const override {
+            return false;
+        }
 
         typedef Expression INHERITED;
     };
diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp
index ab64e66..8099d45 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.cpp
+++ b/src/sksl/SkSLGLSLCodeGenerator.cpp
@@ -14,6 +14,7 @@
 #include "ir/SkSLExtension.h"
 #include "ir/SkSLIndexExpression.h"
 #include "ir/SkSLModifiersDeclaration.h"
+#include "ir/SkSLNop.h"
 #include "ir/SkSLVariableReference.h"
 
 namespace SkSL {
@@ -509,10 +510,7 @@
     StringStream buffer;
     fOut = &buffer;
     fIndentation++;
-    for (const auto& s : f.fBody->fStatements) {
-        this->writeStatement(*s);
-        this->writeLine();
-    }
+    this->writeStatements(((Block&) *f.fBody).fStatements);
     fIndentation--;
     this->writeLine("}");
 
@@ -620,26 +618,26 @@
 
 void GLSLCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, bool global) {
     ASSERT(decl.fVars.size() > 0);
-    this->writeModifiers(decl.fVars[0].fVar->fModifiers, global);
+    this->writeModifiers(decl.fVars[0]->fVar->fModifiers, global);
     this->writeType(decl.fBaseType);
     String separator(" ");
     for (const auto& var : decl.fVars) {
-        ASSERT(var.fVar->fModifiers == decl.fVars[0].fVar->fModifiers);
+        ASSERT(var->fVar->fModifiers == decl.fVars[0]->fVar->fModifiers);
         this->write(separator);
         separator = String(", ");
-        this->write(var.fVar->fName);
-        for (const auto& size : var.fSizes) {
+        this->write(var->fVar->fName);
+        for (const auto& size : var->fSizes) {
             this->write("[");
             if (size) {
                 this->writeExpression(*size, kTopLevel_Precedence);
             }
             this->write("]");
         }
-        if (var.fValue) {
+        if (var->fValue) {
             this->write(" = ");
-            this->writeExpression(*var.fValue, kTopLevel_Precedence);
+            this->writeExpression(*var->fValue, kTopLevel_Precedence);
         }
-        if (!fFoundImageDecl && var.fVar->fType == *fContext.fImage2D_Type) {
+        if (!fFoundImageDecl && var->fVar->fType == *fContext.fImage2D_Type) {
             if (fProgram.fSettings.fCaps->imageLoadStoreExtensionString()) {
                 fHeader.writeText("#extension ");
                 fHeader.writeText(fProgram.fSettings.fCaps->imageLoadStoreExtensionString());
@@ -690,18 +688,27 @@
         case Statement::kDiscard_Kind:
             this->write("discard;");
             break;
+        case Statement::kNop_Kind:
+            this->write(";");
+            break;
         default:
             ABORT("unsupported statement: %s", s.description().c_str());
     }
 }
 
+void GLSLCodeGenerator::writeStatements(const std::vector<std::unique_ptr<Statement>>& statements) {
+    for (const auto& s : statements) {
+        if (!s->isEmpty()) {
+            this->writeStatement(*s);
+            this->writeLine();
+        }
+    }
+}
+
 void GLSLCodeGenerator::writeBlock(const Block& b) {
     this->writeLine("{");
     fIndentation++;
-    for (const auto& s : b.fStatements) {
-        this->writeStatement(*s);
-        this->writeLine();
-    }
+    this->writeStatements(b.fStatements);
     fIndentation--;
     this->write("}");
 }
@@ -821,7 +828,7 @@
             case ProgramElement::kVar_Kind: {
                 VarDeclarations& decl = (VarDeclarations&) *e;
                 if (decl.fVars.size() > 0) {
-                    int builtin = decl.fVars[0].fVar->fModifiers.fLayout.fBuiltin;
+                    int builtin = decl.fVars[0]->fVar->fModifiers.fLayout.fBuiltin;
                     if (builtin == -1) {
                         // normal var
                         this->writeVarDeclarations(decl, true);
diff --git a/src/sksl/SkSLGLSLCodeGenerator.h b/src/sksl/SkSLGLSLCodeGenerator.h
index ab88d50..65be7dc 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.h
+++ b/src/sksl/SkSLGLSLCodeGenerator.h
@@ -145,6 +145,8 @@
 
     void writeStatement(const Statement& s);
 
+    void writeStatements(const std::vector<std::unique_ptr<Statement>>& statements);
+
     void writeBlock(const Block& b);
 
     void writeIfStatement(const IfStatement& stmt);
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
index 975b05f..56858a9 100644
--- a/src/sksl/SkSLIRGenerator.cpp
+++ b/src/sksl/SkSLIRGenerator.cpp
@@ -210,7 +210,7 @@
 
 std::unique_ptr<VarDeclarations> IRGenerator::convertVarDeclarations(const ASTVarDeclarations& decl,
                                                                      Variable::Storage storage) {
-    std::vector<VarDeclaration> variables;
+    std::vector<std::unique_ptr<VarDeclaration>> variables;
     const Type* baseType = this->convertType(*decl.fType);
     if (!baseType) {
         return nullptr;
@@ -254,6 +254,7 @@
                 return nullptr;
             }
             value = this->coerce(std::move(value), *type);
+            var->fWriteCount = 1;
         }
         if (storage == Variable::kGlobal_Storage && varDecl.fName == String("sk_FragColor") &&
             (*fSymbolTable)[varDecl.fName]) {
@@ -265,7 +266,8 @@
             Variable* old = (Variable*) (*fSymbolTable)[varDecl.fName];
             old->fModifiers = var->fModifiers;
         } else {
-            variables.emplace_back(var.get(), std::move(sizes), std::move(value));
+            variables.emplace_back(new VarDeclaration(var.get(), std::move(sizes),
+                                                      std::move(value)));
             fSymbolTable->add(varDecl.fName, std::move(var));
         }
     }
@@ -542,7 +544,8 @@
                 }
                 if (match) {
                     if (*returnType != other->fReturnType) {
-                        FunctionDeclaration newDecl(f.fPosition, f.fName, parameters, *returnType);
+                        FunctionDeclaration newDecl(f.fPosition, f.fModifiers, f.fName, parameters,
+                                                    *returnType);
                         fErrors.error(f.fPosition, "functions '" + newDecl.description() +
                                                    "' and '" + other->description() +
                                                    "' differ only in return type");
@@ -570,6 +573,7 @@
     if (!decl) {
         // couldn't find an existing declaration
         auto newDecl = std::unique_ptr<FunctionDeclaration>(new FunctionDeclaration(f.fPosition,
+                                                                                    f.fModifiers,
                                                                                     f.fName,
                                                                                     parameters,
                                                                                     *returnType));
@@ -590,6 +594,8 @@
         if (!body) {
             return nullptr;
         }
+        // conservatively assume all user-defined functions have side effects
+        ((Modifiers&) decl->fModifiers).fFlags |= Modifiers::kHasSideEffects_Flag;
         return std::unique_ptr<FunctionDefinition>(new FunctionDefinition(f.fPosition, *decl,
                                                                           std::move(body)));
     }
@@ -608,16 +614,16 @@
             return nullptr;
         }
         for (const auto& var : decl->fVars) {
-            fields.push_back(Type::Field(var.fVar->fModifiers, var.fVar->fName,
-                                         &var.fVar->fType));
-            if (var.fValue) {
+            fields.push_back(Type::Field(var->fVar->fModifiers, var->fVar->fName,
+                                         &var->fVar->fType));
+            if (var->fValue) {
                 fErrors.error(decl->fPosition,
                               "initializers are not permitted on interface block fields");
             }
-            if (var.fVar->fModifiers.fFlags & (Modifiers::kIn_Flag |
-                                               Modifiers::kOut_Flag |
-                                               Modifiers::kUniform_Flag |
-                                               Modifiers::kConst_Flag)) {
+            if (var->fVar->fModifiers.fFlags & (Modifiers::kIn_Flag |
+                                                Modifiers::kOut_Flag |
+                                                Modifiers::kUniform_Flag |
+                                                Modifiers::kConst_Flag)) {
                 fErrors.error(decl->fPosition,
                               "interface block fields may not have storage qualifiers");
             }
@@ -944,6 +950,9 @@
 std::unique_ptr<Expression> IRGenerator::constantFold(const Expression& left,
                                                       Token::Kind op,
                                                       const Expression& right) const {
+    if (!left.isConstant() || !right.isConstant()) {
+        return nullptr;
+    }
     // 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
@@ -967,9 +976,9 @@
         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::PLUS:       return RESULT(Int, +);
+            case Token::MINUS:      return RESULT(Int, -);
+            case Token::STAR:       return RESULT(Int, *);
             case Token::SLASH:
                 if (rightVal) {
                     return RESULT(Int, /);
@@ -1010,15 +1019,37 @@
                 }
                 fErrors.error(right.fPosition, "division by zero");
                 return nullptr;
-            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,  <=);
+            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.fType.kind() == Type::kVector_Kind &&
+        left.fType.componentType() == *fContext.fFloat_Type &&
+        left.fType == right.fType) {
+        ASSERT(left.fKind  == Expression::kConstructor_Kind);
+        ASSERT(right.fKind == Expression::kConstructor_Kind);
+        std::vector<std::unique_ptr<Expression>> args;
+        #define RETURN_VEC_COMPONENTWISE_RESULT(op)                                    \
+            for (int i = 0; i < left.fType.columns(); i++) {                           \
+                float value = ((Constructor&) left).getFVecComponent(i) op             \
+                              ((Constructor&) right).getFVecComponent(i);              \
+                args.emplace_back(new FloatLiteral(fContext, Position(), value));      \
+            }                                                                          \
+            return std::unique_ptr<Expression>(new Constructor(Position(), left.fType, \
+                                                               std::move(args)));
+        switch (op) {
+            case Token::PLUS:  RETURN_VEC_COMPONENTWISE_RESULT(+);
+            case Token::MINUS: RETURN_VEC_COMPONENTWISE_RESULT(-);
+            case Token::STAR:  RETURN_VEC_COMPONENTWISE_RESULT(*);
+            case Token::SLASH: RETURN_VEC_COMPONENTWISE_RESULT(/);
+            default:           return nullptr;
+        }
+    }
     #undef RESULT
     return nullptr;
 }
@@ -1177,7 +1208,8 @@
             return nullptr;
         }
         if (arguments[i] && (function.fParameters[i]->fModifiers.fFlags & Modifiers::kOut_Flag)) {
-            this->markWrittenTo(*arguments[i], true);
+            this->markWrittenTo(*arguments[i], 
+                                function.fParameters[i]->fModifiers.fFlags & Modifiers::kIn_Flag);
         }
     }
     if (function.fBuiltin && function.fName == "texture" &&
diff --git a/src/sksl/SkSLParser.cpp b/src/sksl/SkSLParser.cpp
index 0f2b943..ae9d990 100644
--- a/src/sksl/SkSLParser.cpp
+++ b/src/sksl/SkSLParser.cpp
@@ -309,7 +309,7 @@
     if (!this->expect(Token::IDENTIFIER, "an identifier", &name)) {
         return nullptr;
     }
-    if (!modifiers.fFlags && this->peek().fKind == Token::LPAREN) {
+    if (this->peek().fKind == Token::LPAREN) {
         this->nextToken();
         std::vector<std::unique_ptr<ASTParameter>> parameters;
         while (this->peek().fKind != Token::RPAREN) {
@@ -334,7 +334,9 @@
                 return nullptr;
             }
         }
-        return std::unique_ptr<ASTDeclaration>(new ASTFunction(name.fPosition, std::move(type),
+        return std::unique_ptr<ASTDeclaration>(new ASTFunction(name.fPosition,
+                                                               modifiers,
+                                                               std::move(type),
                                                                std::move(name.fText),
                                                                std::move(parameters),
                                                                std::move(body)));
@@ -721,6 +723,10 @@
                 this->nextToken();
                 flags |= Modifiers::kRestrict_Flag;
                 break;
+            case Token::HASSIDEEFFECTS:
+                this->nextToken();
+                flags |= Modifiers::kHasSideEffects_Flag;
+                break;
             default:
                 return Modifiers(layout, flags);
         }
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp
index d713d6f..d2850e9 100644
--- a/src/sksl/SkSLSPIRVCodeGenerator.cpp
+++ b/src/sksl/SkSLSPIRVCodeGenerator.cpp
@@ -2461,7 +2461,7 @@
         write_stringstream(fGlobalInitializersBuffer, out);
     }
     StringStream bodyBuffer;
-    this->writeBlock(*f.fBody, bodyBuffer);
+    this->writeBlock((Block&) *f.fBody, bodyBuffer);
     write_stringstream(fVariableBuffer, out);
     write_stringstream(bodyBuffer, out);
     if (fCurrentBlock) {
@@ -2558,7 +2558,7 @@
 void SPIRVCodeGenerator::writeGlobalVars(Program::Kind kind, const VarDeclarations& decl,
                                          OutputStream& out) {
     for (size_t i = 0; i < decl.fVars.size(); i++) {
-        const VarDeclaration& varDecl = decl.fVars[i];
+        const VarDeclaration& varDecl = *decl.fVars[i];
         const Variable* var = varDecl.fVar;
         // These haven't been implemented in our SPIR-V generator yet and we only currently use them
         // in the OpenGL backend.
@@ -2620,7 +2620,7 @@
 
 void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, OutputStream& out) {
     for (const auto& varDecl : decl.fVars) {
-        const Variable* var = varDecl.fVar;
+        const Variable* var = varDecl->fVar;
         // These haven't been implemented in our SPIR-V generator yet and we only currently use them
         // in the OpenGL backend.
         ASSERT(!(var->fModifiers.fFlags & (Modifiers::kReadOnly_Flag |
@@ -2633,8 +2633,8 @@
         SpvId type = this->getPointerType(var->fType, SpvStorageClassFunction);
         this->writeInstruction(SpvOpVariable, type, id, SpvStorageClassFunction, fVariableBuffer);
         this->writeInstruction(SpvOpName, id, var->fName.c_str(), fNameBuffer);
-        if (varDecl.fValue) {
-            SpvId value = this->writeExpression(*varDecl.fValue, out);
+        if (varDecl->fValue) {
+            SpvId value = this->writeExpression(*varDecl->fValue, out);
             this->writeInstruction(SpvOpStore, id, value, out);
         }
     }
@@ -2642,6 +2642,8 @@
 
 void SPIRVCodeGenerator::writeStatement(const Statement& s, OutputStream& out) {
     switch (s.fKind) {
+        case Statement::kNop_Kind:
+            break;
         case Statement::kBlock_Kind:
             this->writeBlock((Block&) s, out);
             break;
diff --git a/src/sksl/SkSLToken.h b/src/sksl/SkSLToken.h
index 8732e80..874c7eb 100644
--- a/src/sksl/SkSLToken.h
+++ b/src/sksl/SkSLToken.h
@@ -104,6 +104,7 @@
         COHERENT,
         VOLATILE,
         RESTRICT,
+        HASSIDEEFFECTS,
         STRUCT,
         LAYOUT,
         DIRECTIVE,
diff --git a/src/sksl/ast/SkSLASTFunction.h b/src/sksl/ast/SkSLASTFunction.h
index d9f3067..0dff3ae 100644
--- a/src/sksl/ast/SkSLASTFunction.h
+++ b/src/sksl/ast/SkSLASTFunction.h
@@ -19,10 +19,11 @@
  * A function declaration or definition. The fBody field will be null for declarations.
  */
 struct ASTFunction : public ASTDeclaration {
-    ASTFunction(Position position, std::unique_ptr<ASTType> returnType, String name,
-                std::vector<std::unique_ptr<ASTParameter>> parameters,
+    ASTFunction(Position position, Modifiers modifiers,  std::unique_ptr<ASTType> returnType,
+                String name, std::vector<std::unique_ptr<ASTParameter>> parameters, 
                 std::unique_ptr<ASTBlock> body)
     : INHERITED(position, kFunction_Kind)
+    , fModifiers(modifiers)
     , fReturnType(std::move(returnType))
     , fName(std::move(name))
     , fParameters(std::move(parameters))
@@ -44,6 +45,7 @@
         return result;
     }
 
+    const Modifiers fModifiers;
     const std::unique_ptr<ASTType> fReturnType;
     const String fName;
     const std::vector<std::unique_ptr<ASTParameter>> fParameters;
diff --git a/src/sksl/ir/SkSLBinaryExpression.h b/src/sksl/ir/SkSLBinaryExpression.h
index 73b1829..789db57 100644
--- a/src/sksl/ir/SkSLBinaryExpression.h
+++ b/src/sksl/ir/SkSLBinaryExpression.h
@@ -26,15 +26,19 @@
     , fOperator(op)
     , fRight(std::move(right)) {}
 
-    virtual std::unique_ptr<Expression> constantPropagate(
-                                                        const IRGenerator& irGenerator,
-                                                        const DefinitionMap& definitions) override {
+    std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
+                                                  const DefinitionMap& definitions) override {
         return irGenerator.constantFold(*fLeft,
                                         fOperator,
                                         *fRight);
     }
 
-    virtual String description() const override {
+    bool hasSideEffects() const override {
+        return Token::IsAssignment(fOperator) || fLeft->hasSideEffects() ||
+               fRight->hasSideEffects();
+    }
+
+    String description() const override {
         return "(" + fLeft->description() + " " + Token::OperatorName(fOperator) + " " +
                fRight->description() + ")";
     }
diff --git a/src/sksl/ir/SkSLBlock.h b/src/sksl/ir/SkSLBlock.h
index fe58d44..1197666 100644
--- a/src/sksl/ir/SkSLBlock.h
+++ b/src/sksl/ir/SkSLBlock.h
@@ -23,6 +23,15 @@
     , fSymbols(std::move(symbols))
     , fStatements(std::move(statements)) {}
 
+    bool isEmpty() const override {
+        for (const auto& s : fStatements) {
+            if (!s->isEmpty()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     String description() const override {
         String result("{");
         for (size_t i = 0; i < fStatements.size(); i++) {
@@ -36,7 +45,7 @@
     // it's important to keep fStatements defined after (and thus destroyed before) fSymbols,
     // because destroying statements can modify reference counts in symbols
     const std::shared_ptr<SymbolTable> fSymbols;
-    const std::vector<std::unique_ptr<Statement>> fStatements;
+    std::vector<std::unique_ptr<Statement>> fStatements;
 
     typedef Statement INHERITED;
 };
diff --git a/src/sksl/ir/SkSLBoolLiteral.h b/src/sksl/ir/SkSLBoolLiteral.h
index 4e1e050..13203a4 100644
--- a/src/sksl/ir/SkSLBoolLiteral.h
+++ b/src/sksl/ir/SkSLBoolLiteral.h
@@ -25,6 +25,10 @@
         return String(fValue ? "true" : "false");
     }
 
+    bool hasSideEffects() const override {
+        return false;
+    }
+
     bool isConstant() const override {
         return true;
     }
diff --git a/src/sksl/ir/SkSLConstructor.h b/src/sksl/ir/SkSLConstructor.h
index 5c647c7..208031a 100644
--- a/src/sksl/ir/SkSLConstructor.h
+++ b/src/sksl/ir/SkSLConstructor.h
@@ -30,20 +30,36 @@
     : INHERITED(position, kConstructor_Kind, type)
     , fArguments(std::move(arguments)) {}
 
-    virtual std::unique_ptr<Expression> constantPropagate(
-                                                        const IRGenerator& irGenerator,
-                                                        const DefinitionMap& definitions) override {
-        if (fArguments.size() == 1 && fArguments[0]->fKind == Expression::kIntLiteral_Kind &&
-            // promote float(1) to 1.0
-            fType == *irGenerator.fContext.fFloat_Type) {
-            int64_t intValue = ((IntLiteral&) *fArguments[0]).fValue;
-            return std::unique_ptr<Expression>(new FloatLiteral(irGenerator.fContext,
-                                                                fPosition,
-                                                                intValue));
+    std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
+                                                  const DefinitionMap& definitions) override {
+        if (fArguments.size() == 1 && fArguments[0]->fKind == Expression::kIntLiteral_Kind) {
+            if (fType == *irGenerator.fContext.fFloat_Type) {
+                // promote float(1) to 1.0
+                int64_t intValue = ((IntLiteral&) *fArguments[0]).fValue;
+                return std::unique_ptr<Expression>(new FloatLiteral(irGenerator.fContext,
+                                                                    fPosition,
+                                                                    intValue));
+            } else if (fType == *irGenerator.fContext.fUInt_Type) {
+                // promote uint(1) to 1u
+                int64_t intValue = ((IntLiteral&) *fArguments[0]).fValue;
+                return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
+                                                                  fPosition,
+                                                                  intValue,
+                                                                  &fType));
+            }
         }
         return nullptr;
     }
 
+    bool hasSideEffects() const override {
+        for (const auto& arg : fArguments) {
+            if (arg->hasSideEffects()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     String description() const override {
         String result = fType.description() + "(";
         String separator;
@@ -65,6 +81,43 @@
         return true;
     }
 
+    const Expression& getVecComponent(int index) const {
+        ASSERT(fType.kind() == Type::kVector_Kind);
+        if (fArguments.size() == 1 && fArguments[0]->fType.kind() == Type::kScalar_Kind) {
+            return *fArguments[0];
+        }
+        int current = 0;
+        for (const auto& arg : fArguments) {
+            ASSERT(current <= index);
+            if (arg->fType.kind() == Type::kScalar_Kind) {
+                if (index == current) {
+                    return *arg;
+                }
+                current++;
+            } else {
+                ASSERT(arg->fType.kind() == Type::kVector_Kind);
+                ASSERT(arg->fKind == Expression::kConstructor_Kind);
+                if (current + arg->fType.columns() > index) {
+                    return ((const Constructor&) *arg).getVecComponent(index - current);
+                }
+                current += arg->fType.columns();
+            }
+        }
+        ABORT("failed to find vector component %d in %s\n", index, description().c_str());
+    }
+
+    double getFVecComponent(int index) const {
+        const Expression& c = this->getVecComponent(index);
+        ASSERT(c.fKind == Expression::kFloatLiteral_Kind);
+        return ((FloatLiteral&) c).fValue;
+    }
+
+    int64_t getIVecComponent(int index) const {
+        const Expression& c = this->getVecComponent(index);
+        ASSERT(c.fKind == Expression::kIntLiteral_Kind);
+        return ((IntLiteral&) c).fValue;
+    }
+
     std::vector<std::unique_ptr<Expression>> fArguments;
 
     typedef Expression INHERITED;
diff --git a/src/sksl/ir/SkSLDoStatement.h b/src/sksl/ir/SkSLDoStatement.h
index 4d3d348..f1ecd9a 100644
--- a/src/sksl/ir/SkSLDoStatement.h
+++ b/src/sksl/ir/SkSLDoStatement.h
@@ -27,7 +27,7 @@
         return "do " + fStatement->description() + " while (" + fTest->description() + ");";
     }
 
-    const std::unique_ptr<Statement> fStatement;
+    std::unique_ptr<Statement> fStatement;
     std::unique_ptr<Expression> fTest;
 
     typedef Statement INHERITED;
diff --git a/src/sksl/ir/SkSLExpression.h b/src/sksl/ir/SkSLExpression.h
index f87d810..5db9ddf 100644
--- a/src/sksl/ir/SkSLExpression.h
+++ b/src/sksl/ir/SkSLExpression.h
@@ -53,6 +53,13 @@
     }
 
     /**
+     * Returns true if evaluating the expression potentially has side effects. Expressions may never
+     * return false if they actually have side effects, but it is legal (though suboptimal) to
+     * return true if there are not actually any side effects.
+     */
+    virtual bool hasSideEffects() const = 0;
+
+    /**
      * Given a map of known constant variable values, substitute them in for references to those
      * variables occurring in this expression and its subexpressions.  Similar simplifications, such
      * as folding a constant binary expression down to a single value, may also be performed.
diff --git a/src/sksl/ir/SkSLFieldAccess.h b/src/sksl/ir/SkSLFieldAccess.h
index eead41c..e0a335f 100644
--- a/src/sksl/ir/SkSLFieldAccess.h
+++ b/src/sksl/ir/SkSLFieldAccess.h
@@ -31,7 +31,11 @@
     , fFieldIndex(fieldIndex)
     , fOwnerKind(ownerKind) {}
 
-    virtual String description() const override {
+    bool hasSideEffects() const override {
+        return fBase->hasSideEffects();
+    }
+
+    String description() const override {
         return fBase->description() + "." + fBase->fType.fields()[fFieldIndex].fName;
     }
 
diff --git a/src/sksl/ir/SkSLFloatLiteral.h b/src/sksl/ir/SkSLFloatLiteral.h
index 5ed1235..8f83e28 100644
--- a/src/sksl/ir/SkSLFloatLiteral.h
+++ b/src/sksl/ir/SkSLFloatLiteral.h
@@ -17,14 +17,19 @@
  * A literal floating point number.
  */
 struct FloatLiteral : public Expression {
-    FloatLiteral(const Context& context, Position position, double value)
-    : INHERITED(position, kFloatLiteral_Kind, *context.fFloat_Type)
+    FloatLiteral(const Context& context, Position position, double value,
+                 const Type* type = nullptr)
+    : INHERITED(position, kFloatLiteral_Kind, type ? *type : *context.fFloat_Type)
     , fValue(value) {}
 
-    virtual String description() const override {
+    String description() const override {
         return to_string(fValue);
     }
 
+    bool hasSideEffects() const override {
+        return false;
+    }
+
     bool isConstant() const override {
         return true;
     }
diff --git a/src/sksl/ir/SkSLForStatement.h b/src/sksl/ir/SkSLForStatement.h
index b72c26b..ca3e6cf 100644
--- a/src/sksl/ir/SkSLForStatement.h
+++ b/src/sksl/ir/SkSLForStatement.h
@@ -48,10 +48,10 @@
     // it's important to keep fSymbols defined first (and thus destroyed last) because destroying
     // the other fields can update symbol reference counts
     const std::shared_ptr<SymbolTable> fSymbols;
-    const std::unique_ptr<Statement> fInitializer;
+    std::unique_ptr<Statement> fInitializer;
     std::unique_ptr<Expression> fTest;
     std::unique_ptr<Expression> fNext;
-    const std::unique_ptr<Statement> fStatement;
+    std::unique_ptr<Statement> fStatement;
 
     typedef Statement INHERITED;
 };
diff --git a/src/sksl/ir/SkSLFunctionCall.h b/src/sksl/ir/SkSLFunctionCall.h
index 1a5c6fd..44f8c7e 100644
--- a/src/sksl/ir/SkSLFunctionCall.h
+++ b/src/sksl/ir/SkSLFunctionCall.h
@@ -23,6 +23,15 @@
     , fFunction(std::move(function))
     , fArguments(std::move(arguments)) {}
 
+    bool hasSideEffects() const override {
+        for (const auto& arg : fArguments) {
+            if (arg->hasSideEffects()) {
+                return true;
+            }
+        }
+        return fFunction.fModifiers.fFlags & Modifiers::kHasSideEffects_Flag;
+    }
+
     String description() const override {
         String result = fFunction.fName + "(";
         String separator;
diff --git a/src/sksl/ir/SkSLFunctionDeclaration.h b/src/sksl/ir/SkSLFunctionDeclaration.h
index 05ba03a..8704c9a 100644
--- a/src/sksl/ir/SkSLFunctionDeclaration.h
+++ b/src/sksl/ir/SkSLFunctionDeclaration.h
@@ -21,11 +21,12 @@
  * A function declaration (not a definition -- does not contain a body).
  */
 struct FunctionDeclaration : public Symbol {
-    FunctionDeclaration(Position position, String name,
+    FunctionDeclaration(Position position, Modifiers modifiers, String name,
                         std::vector<const Variable*> parameters, const Type& returnType)
     : INHERITED(position, kFunctionDeclaration_Kind, std::move(name))
     , fDefined(false)
     , fBuiltin(false)
+    , fModifiers(modifiers)
     , fParameters(std::move(parameters))
     , fReturnType(returnType) {}
 
@@ -102,6 +103,7 @@
 
     mutable bool fDefined;
     bool fBuiltin;
+    Modifiers fModifiers;
     const std::vector<const Variable*> fParameters;
     const Type& fReturnType;
 
diff --git a/src/sksl/ir/SkSLFunctionDefinition.h b/src/sksl/ir/SkSLFunctionDefinition.h
index e87ee63..0277db1 100644
--- a/src/sksl/ir/SkSLFunctionDefinition.h
+++ b/src/sksl/ir/SkSLFunctionDefinition.h
@@ -19,7 +19,7 @@
  */
 struct FunctionDefinition : public ProgramElement {
     FunctionDefinition(Position position, const FunctionDeclaration& declaration,
-                       std::unique_ptr<Block> body)
+                       std::unique_ptr<Statement> body)
     : INHERITED(position, kFunction_Kind)
     , fDeclaration(declaration)
     , fBody(std::move(body)) {}
@@ -29,7 +29,7 @@
     }
 
     const FunctionDeclaration& fDeclaration;
-    const std::unique_ptr<Block> fBody;
+    std::unique_ptr<Statement> fBody;
 
     typedef ProgramElement INHERITED;
 };
diff --git a/src/sksl/ir/SkSLFunctionReference.h b/src/sksl/ir/SkSLFunctionReference.h
index 49ddf83..ee761c2 100644
--- a/src/sksl/ir/SkSLFunctionReference.h
+++ b/src/sksl/ir/SkSLFunctionReference.h
@@ -24,7 +24,11 @@
     : INHERITED(position, kFunctionReference_Kind, *context.fInvalid_Type)
     , fFunctions(function) {}
 
-    virtual String description() const override {
+    bool hasSideEffects() const override {
+        return false;
+    }
+
+    String description() const override {
         ASSERT(false);
         return String("<function>");
     }
diff --git a/src/sksl/ir/SkSLIfStatement.h b/src/sksl/ir/SkSLIfStatement.h
index a7e0aad..0377b12 100644
--- a/src/sksl/ir/SkSLIfStatement.h
+++ b/src/sksl/ir/SkSLIfStatement.h
@@ -33,8 +33,9 @@
     }
 
     std::unique_ptr<Expression> fTest;
-    const std::unique_ptr<Statement> fIfTrue;
-    const std::unique_ptr<Statement> fIfFalse;
+    std::unique_ptr<Statement> fIfTrue;
+    // may be null
+    std::unique_ptr<Statement> fIfFalse;
 
     typedef Statement INHERITED;
 };
diff --git a/src/sksl/ir/SkSLIndexExpression.h b/src/sksl/ir/SkSLIndexExpression.h
index 68823bf..49633b6 100644
--- a/src/sksl/ir/SkSLIndexExpression.h
+++ b/src/sksl/ir/SkSLIndexExpression.h
@@ -51,6 +51,10 @@
         ASSERT(fIndex->fType == *context.fInt_Type || fIndex->fType == *context.fUInt_Type);
     }
 
+    bool hasSideEffects() const override {
+        return fBase->hasSideEffects() || fIndex->hasSideEffects();
+    }
+
     String description() const override {
         return fBase->description() + "[" + fIndex->description() + "]";
     }
diff --git a/src/sksl/ir/SkSLIntLiteral.h b/src/sksl/ir/SkSLIntLiteral.h
index 2322a3d..3a95ed6 100644
--- a/src/sksl/ir/SkSLIntLiteral.h
+++ b/src/sksl/ir/SkSLIntLiteral.h
@@ -23,11 +23,15 @@
     : INHERITED(position, kIntLiteral_Kind, type ? *type : *context.fInt_Type)
     , fValue(value) {}
 
-    virtual String description() const override {
+    String description() const override {
         return to_string(fValue);
     }
 
-   bool isConstant() const override {
+    bool hasSideEffects() const override {
+        return false;
+    }
+
+    bool isConstant() const override {
         return true;
     }
 
diff --git a/src/sksl/ir/SkSLModifiers.h b/src/sksl/ir/SkSLModifiers.h
index 9fae5b0..8aaf2ae 100644
--- a/src/sksl/ir/SkSLModifiers.h
+++ b/src/sksl/ir/SkSLModifiers.h
@@ -17,21 +17,22 @@
  */
 struct Modifiers {
     enum Flag {
-        kNo_Flag            =    0,
-        kConst_Flag         =    1,
-        kIn_Flag            =    2,
-        kOut_Flag           =    4,
-        kLowp_Flag          =    8,
-        kMediump_Flag       =   16,
-        kHighp_Flag         =   32,
-        kUniform_Flag       =   64,
-        kFlat_Flag          =  128,
-        kNoPerspective_Flag =  256,
-        kReadOnly_Flag      =  512,
-        kWriteOnly_Flag     = 1024,
-        kCoherent_Flag      = 2048,
-        kVolatile_Flag      = 4096,
-        kRestrict_Flag      = 8192
+        kNo_Flag             =       0,
+        kConst_Flag          = 1 <<  0,
+        kIn_Flag             = 1 <<  1,
+        kOut_Flag            = 1 <<  2,
+        kLowp_Flag           = 1 <<  3,
+        kMediump_Flag        = 1 <<  4,
+        kHighp_Flag          = 1 <<  5,
+        kUniform_Flag        = 1 <<  6,
+        kFlat_Flag           = 1 <<  7,
+        kNoPerspective_Flag  = 1 <<  8,
+        kReadOnly_Flag       = 1 <<  9,
+        kWriteOnly_Flag      = 1 << 10,
+        kCoherent_Flag       = 1 << 11,
+        kVolatile_Flag       = 1 << 12,
+        kRestrict_Flag       = 1 << 13,
+        kHasSideEffects_Flag = 1 << 14
     };
 
     Modifiers()
@@ -80,6 +81,9 @@
         if (fFlags & kRestrict_Flag) {
             result += "restrict ";
         }
+        if (fFlags & kHasSideEffects_Flag) {
+            result += "sk_has_side_effects ";
+        }
 
         if ((fFlags & kIn_Flag) && (fFlags & kOut_Flag)) {
             result += "inout ";
diff --git a/src/sksl/ir/SkSLNop.h b/src/sksl/ir/SkSLNop.h
new file mode 100644
index 0000000..5ebea40
--- /dev/null
+++ b/src/sksl/ir/SkSLNop.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SKSL_NOP
+#define SKSL_NOP
+
+#include "SkSLStatement.h"
+#include "SkSLSymbolTable.h"
+
+namespace SkSL {
+
+/**
+ * A no-op statement that does nothing.
+ */
+struct Nop : public Statement {
+    Nop()
+    : INHERITED(Position(), kNop_Kind) {}
+
+    virtual bool isEmpty() const override {
+        return true;
+    }
+
+    String description() const override {
+        return String(";");
+    }
+
+    typedef Statement INHERITED;
+};
+
+} // namespace
+
+#endif
diff --git a/src/sksl/ir/SkSLPostfixExpression.h b/src/sksl/ir/SkSLPostfixExpression.h
index 2c84af7..e02555d 100644
--- a/src/sksl/ir/SkSLPostfixExpression.h
+++ b/src/sksl/ir/SkSLPostfixExpression.h
@@ -22,7 +22,11 @@
     , fOperand(std::move(operand))
     , fOperator(op) {}
 
-    virtual String description() const override {
+    bool hasSideEffects() const override {
+        return true;
+    }
+
+    String description() const override {
         return fOperand->description() + Token::OperatorName(fOperator);
     }
 
diff --git a/src/sksl/ir/SkSLPrefixExpression.h b/src/sksl/ir/SkSLPrefixExpression.h
index 4fa54ca..a61ff65 100644
--- a/src/sksl/ir/SkSLPrefixExpression.h
+++ b/src/sksl/ir/SkSLPrefixExpression.h
@@ -22,7 +22,29 @@
     , fOperand(std::move(operand))
     , fOperator(op) {}
 
-    virtual String description() const override {
+    bool isConstant() const override {
+        return fOperator == Token::MINUS && fOperand->isConstant();
+    }
+
+    bool hasSideEffects() const override {
+        return fOperator == Token::PLUSPLUS || fOperator == Token::MINUSMINUS ||
+               fOperand->hasSideEffects();
+    }
+
+    virtual std::unique_ptr<Expression> constantPropagate(
+                                                        const IRGenerator& irGenerator,
+                                                        const DefinitionMap& definitions) override {
+        if (fOperand->fKind == Expression::kFloatLiteral_Kind) {
+            return std::unique_ptr<Expression>(new FloatLiteral(
+                                                              irGenerator.fContext,
+                                                              Position(),
+                                                              -((FloatLiteral&) *fOperand).fValue));
+
+        }
+        return nullptr;
+    }
+
+    String description() const override {
         return Token::OperatorName(fOperator) + fOperand->description();
     }
 
diff --git a/src/sksl/ir/SkSLStatement.h b/src/sksl/ir/SkSLStatement.h
index ba1a087..9af18ec 100644
--- a/src/sksl/ir/SkSLStatement.h
+++ b/src/sksl/ir/SkSLStatement.h
@@ -25,7 +25,9 @@
         kDo_Kind,
         kExpression_Kind,
         kFor_Kind,
+        kGroup_Kind,
         kIf_Kind,
+        kNop_Kind,
         kReturn_Kind,
         kSwitch_Kind,
         kVarDeclarations_Kind,
@@ -36,6 +38,10 @@
     : INHERITED(position)
     , fKind(kind) {}
 
+    virtual bool isEmpty() const {
+        return false;
+    }
+
     const Kind fKind;
 
     typedef IRNode INHERITED;
diff --git a/src/sksl/ir/SkSLSwizzle.h b/src/sksl/ir/SkSLSwizzle.h
index 1725ec2..dedb81c 100644
--- a/src/sksl/ir/SkSLSwizzle.h
+++ b/src/sksl/ir/SkSLSwizzle.h
@@ -69,6 +69,34 @@
         ASSERT(fComponents.size() >= 1 && fComponents.size() <= 4);
     }
 
+    virtual std::unique_ptr<Expression> constantPropagate(
+                                                        const IRGenerator& irGenerator,
+                                                        const DefinitionMap& definitions) override {
+
+        if (fBase->fKind == Expression::kConstructor_Kind && fBase->isConstant()) {
+            // we're swizzling a constant vector, e.g. vec4(1).x. Simplify it.
+            ASSERT(fBase->fKind == Expression::kConstructor_Kind);
+            if (fType == *irGenerator.fContext.fInt_Type) {
+                ASSERT(fComponents.size() == 1);
+                int64_t value = ((Constructor&) *fBase).getIVecComponent(fComponents[0]);
+                return std::unique_ptr<Expression>(new IntLiteral(irGenerator.fContext,
+                                                                    Position(),
+                                                                    value));
+            } else if (fType == *irGenerator.fContext.fFloat_Type) {
+                ASSERT(fComponents.size() == 1);
+                double value = ((Constructor&) *fBase).getFVecComponent(fComponents[0]);
+                return std::unique_ptr<Expression>(new FloatLiteral(irGenerator.fContext,
+                                                                    Position(),
+                                                                    value));
+            }
+        }
+        return nullptr;
+    }
+
+    bool hasSideEffects() const override {
+        return fBase->hasSideEffects();
+    }
+
     String description() const override {
         String result = fBase->description() + ".";
         for (int x : fComponents) {
diff --git a/src/sksl/ir/SkSLTernaryExpression.h b/src/sksl/ir/SkSLTernaryExpression.h
index 9fbac19..567af56 100644
--- a/src/sksl/ir/SkSLTernaryExpression.h
+++ b/src/sksl/ir/SkSLTernaryExpression.h
@@ -26,6 +26,10 @@
         ASSERT(fIfTrue->fType == fIfFalse->fType);
     }
 
+    bool hasSideEffects() const override {
+        return fTest->hasSideEffects() || fIfTrue->hasSideEffects() || fIfFalse->hasSideEffects();
+    }
+
     String description() const override {
         return "(" + fTest->description() + " ? " + fIfTrue->description() + " : " +
                fIfFalse->description() + ")";
diff --git a/src/sksl/ir/SkSLTypeReference.h b/src/sksl/ir/SkSLTypeReference.h
index b12c185..eae1989 100644
--- a/src/sksl/ir/SkSLTypeReference.h
+++ b/src/sksl/ir/SkSLTypeReference.h
@@ -22,6 +22,10 @@
     : INHERITED(position, kTypeReference_Kind, *context.fInvalid_Type)
     , fValue(type) {}
 
+    bool hasSideEffects() const override {
+        return false;
+    }
+
     String description() const override {
         return fValue.name();
     }
diff --git a/src/sksl/ir/SkSLUnresolvedFunction.h b/src/sksl/ir/SkSLUnresolvedFunction.h
index c5fdbd0..b222bc3 100644
--- a/src/sksl/ir/SkSLUnresolvedFunction.h
+++ b/src/sksl/ir/SkSLUnresolvedFunction.h
@@ -26,7 +26,7 @@
 #endif
     }
 
-    virtual String description() const override {
+    String description() const override {
         return fName;
     }
 
diff --git a/src/sksl/ir/SkSLVarDeclarations.h b/src/sksl/ir/SkSLVarDeclarations.h
index 5a006bd..dbf2928 100644
--- a/src/sksl/ir/SkSLVarDeclarations.h
+++ b/src/sksl/ir/SkSLVarDeclarations.h
@@ -52,8 +52,8 @@
  * A variable declaration statement, which may consist of one or more individual variables.
  */
 struct VarDeclarations : public ProgramElement {
-    VarDeclarations(Position position, const Type* baseType,
-                    std::vector<VarDeclaration> vars)
+    VarDeclarations(Position position, const Type* baseType, 
+                    std::vector<std::unique_ptr<VarDeclaration>> vars)
     : INHERITED(position, kVar_Kind)
     , fBaseType(*baseType)
     , fVars(std::move(vars)) {}
@@ -62,18 +62,18 @@
         if (!fVars.size()) {
             return String();
         }
-        String result = fVars[0].fVar->fModifiers.description() + fBaseType.description() + " ";
+        String result = fVars[0]->fVar->fModifiers.description() + fBaseType.description() + " ";
         String separator;
         for (const auto& var : fVars) {
             result += separator;
             separator = ", ";
-            result += var.description();
+            result += var->description();
         }
         return result;
     }
 
     const Type& fBaseType;
-    std::vector<VarDeclaration> fVars;
+    std::vector<std::unique_ptr<VarDeclaration>> fVars;
 
     typedef ProgramElement INHERITED;
 };
diff --git a/src/sksl/ir/SkSLVariable.h b/src/sksl/ir/SkSLVariable.h
index 21f17ba..05bba20 100644
--- a/src/sksl/ir/SkSLVariable.h
+++ b/src/sksl/ir/SkSLVariable.h
@@ -40,6 +40,10 @@
         return fModifiers.description() + fType.fName + " " + fName;
     }
 
+    bool dead() const {
+        return !fWriteCount || (!fReadCount && !(fModifiers.fFlags & Modifiers::kOut_Flag));
+    }
+
     mutable Modifiers fModifiers;
     const Type& fType;
     const Storage fStorage;
diff --git a/src/sksl/ir/SkSLVariableReference.h b/src/sksl/ir/SkSLVariableReference.h
index af181f8..3b8ebe3 100644
--- a/src/sksl/ir/SkSLVariableReference.h
+++ b/src/sksl/ir/SkSLVariableReference.h
@@ -41,7 +41,7 @@
         }
     }
 
-    virtual ~VariableReference() override {
+    ~VariableReference() override {
         if (fRefKind != kWrite_RefKind) {
             fVariable.fReadCount--;
         }
@@ -67,39 +67,63 @@
         fRefKind = refKind;
     }
 
+    bool hasSideEffects() const override {
+        return false;
+    }
+
     String description() const override {
         return fVariable.fName;
     }
 
-    virtual std::unique_ptr<Expression> constantPropagate(
-                                                        const IRGenerator& irGenerator,
-                                                        const DefinitionMap& definitions) override {
-        auto exprIter = definitions.find(&fVariable);
-        if (exprIter != definitions.end() && exprIter->second) {
-            const Expression* expr = exprIter->second->get();
-            switch (expr->fKind) {
-                case Expression::kIntLiteral_Kind:
-                    return std::unique_ptr<Expression>(new IntLiteral(
-                                                                     irGenerator.fContext,
-                                                                     Position(),
-                                                                     ((IntLiteral*) expr)->fValue));
-                case Expression::kFloatLiteral_Kind:
-                    return std::unique_ptr<Expression>(new FloatLiteral(
-                                                                   irGenerator.fContext,
+    static std::unique_ptr<Expression> copy_constant(const IRGenerator& irGenerator,
+                                                     const Expression* expr) {
+        ASSERT(expr->isConstant());
+        switch (expr->fKind) {
+            case Expression::kIntLiteral_Kind:
+                return std::unique_ptr<Expression>(new IntLiteral(
+                                                                 irGenerator.fContext,
+                                                                 Position(),
+                                                                 ((IntLiteral*) expr)->fValue));
+            case Expression::kFloatLiteral_Kind:
+                return std::unique_ptr<Expression>(new FloatLiteral(
+                                                               irGenerator.fContext,
+                                                               Position(),
+                                                               ((FloatLiteral*) expr)->fValue));
+            case Expression::kBoolLiteral_Kind:
+                return std::unique_ptr<Expression>(new BoolLiteral(irGenerator.fContext,
                                                                    Position(),
-                                                                   ((FloatLiteral*) expr)->fValue));
-                default:
-                    break;
+                                                                   ((BoolLiteral*) expr)->fValue));
+            case Expression::kConstructor_Kind: {
+                const Constructor* c = (const Constructor*) expr;
+                std::vector<std::unique_ptr<Expression>> args;
+                for (const auto& arg : c->fArguments) {
+                    args.push_back(copy_constant(irGenerator, arg.get()));
+                }
+                return std::unique_ptr<Expression>(new Constructor(Position(), c->fType,
+                                                                   std::move(args)));
             }
+            default:
+                ABORT("unsupported constant\n");
+        }
+    }
+
+    std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
+                                                  const DefinitionMap& definitions) override {
+        if (fRefKind != kRead_RefKind) {
+            return nullptr;
+        }
+        auto exprIter = definitions.find(&fVariable);
+        if (exprIter != definitions.end() && exprIter->second &&
+            (*exprIter->second)->isConstant()) {
+            return copy_constant(irGenerator, exprIter->second->get());
         }
         return nullptr;
     }
 
     const Variable& fVariable;
-
-private:
     RefKind fRefKind;
 
+private:
     typedef Expression INHERITED;
 };
 
diff --git a/src/sksl/ir/SkSLWhileStatement.h b/src/sksl/ir/SkSLWhileStatement.h
index c35d6df..6df1619 100644
--- a/src/sksl/ir/SkSLWhileStatement.h
+++ b/src/sksl/ir/SkSLWhileStatement.h
@@ -28,7 +28,7 @@
     }
 
     std::unique_ptr<Expression> fTest;
-    const std::unique_ptr<Statement> fStatement;
+    std::unique_ptr<Statement> fStatement;
 
     typedef Statement INHERITED;
 };
diff --git a/src/sksl/lex.sksl.c b/src/sksl/lex.sksl.c
index ad08251..3ad9034 100644
--- a/src/sksl/lex.sksl.c
+++ b/src/sksl/lex.sksl.c
@@ -424,8 +424,8 @@
 	yyg->yy_hold_char = *yy_cp; \
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 92
-#define YY_END_OF_BUFFER 93
+#define YY_NUM_RULES 93
+#define YY_END_OF_BUFFER 94
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -433,36 +433,37 @@
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static const flex_int16_t yy_accept[253] =
+static const flex_int16_t yy_accept[271] =
     {   0,
-        0,    0,   93,   91,   90,   90,   64,   91,   38,   54,
-       59,   40,   41,   52,   50,   47,   51,   46,   53,    4,
-        4,   66,   87,   71,   67,   70,   65,   44,   45,   58,
-       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-       38,   38,   38,   38,   38,   38,   38,   38,   42,   57,
-       43,   60,   90,   69,   39,   38,   78,   63,   83,   76,
-       48,   74,   49,   75,    1,    0,   88,   77,    2,    4,
-        0,    0,   55,   73,   68,   72,   56,   82,   62,   38,
-       38,   38,   38,   38,   12,   38,   38,   38,   38,   38,
-        8,   20,   38,   38,   38,   38,   38,   38,   38,   38,
+        0,    0,   94,   92,   91,   91,   65,   92,   39,   55,
+       60,   41,   42,   53,   51,   48,   52,   47,   54,    4,
+        4,   67,   88,   72,   68,   71,   66,   45,   46,   59,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   39,   39,   39,   39,   39,   39,   43,   58,
+       44,   61,   91,   70,   40,   39,   79,   64,   84,   77,
+       49,   75,   50,   76,    1,    0,   89,   78,    2,    4,
+        0,    0,   56,   74,   69,   73,   57,   83,   63,   39,
+       39,   39,   39,   39,   12,   39,   39,   39,   39,   39,
+        8,   20,   39,   39,   39,   39,   39,   39,   39,   39,
 
-       38,   38,   38,   38,   38,   38,   81,   61,   39,   86,
-        0,    0,    0,   88,    1,    0,    0,    3,    5,   79,
-       80,   85,   38,   38,   38,   38,   38,   38,   38,   38,
-       38,   10,   38,   38,   38,   38,   38,   38,   21,   38,
-       38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-       84,    0,    1,   89,    0,    0,    2,   38,   14,   38,
-       38,   38,   38,   38,    9,   38,   28,   38,   38,   38,
-       25,   38,   38,   38,   38,   38,   38,   38,   38,    6,
-       38,   38,   38,   38,    0,    1,   16,   38,   24,   38,
-       38,   38,    7,   27,   22,   38,   38,   38,   38,   38,
+       39,   39,   39,   39,   39,   39,   39,   82,   62,   40,
+       87,    0,    0,    0,   89,    1,    0,    0,    3,    5,
+       80,   81,   86,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   10,   39,   39,   39,   39,   39,   39,   21,
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,   85,    0,    1,   90,    0,    0,    2,   39,
+       14,   39,   39,   39,   39,   39,    9,   39,   28,   39,
+       39,   39,   25,   39,   39,   39,   39,   39,   39,   39,
+       39,   39,    6,   39,   39,   39,   39,    0,    1,   16,
+       39,   24,   39,   39,   39,    7,   27,   22,   39,   39,
 
-       38,   38,   38,   38,   38,   38,   11,   38,   38,   38,
-       38,   38,   36,   38,   38,   38,   38,   38,   19,   35,
-       13,   38,   38,   38,   38,   38,   15,   18,   26,   38,
-       38,   38,   38,   23,   38,   38,   32,   17,   38,   38,
-       30,   34,   33,   38,   38,   37,   31,   38,   38,   38,
-       29,    0
+       39,   39,   39,   39,   39,   39,   39,   39,   39,   39,
+       11,   39,   39,   39,   39,   39,   37,   39,   39,   39,
+       39,   39,   19,   39,   36,   13,   39,   39,   39,   39,
+       39,   15,   18,   26,   39,   39,   39,   39,   39,   23,
+       39,   39,   32,   17,   39,   39,   30,   34,   39,   33,
+       39,   39,   38,   39,   31,   39,   39,   39,   39,   39,
+       39,   29,   39,   39,   39,   39,   39,   39,   35,    0
     } ;
 
 static const YY_CHAR yy_ec[256] =
@@ -476,11 +477,11 @@
        22,   23,   24,    1,   25,   25,   25,   25,   26,   25,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
-       27,    1,   28,   29,    6,    1,   30,   31,   32,   33,
+       27,    1,   28,   29,   30,    1,   31,   32,   33,   34,
 
-       34,   35,   36,   37,   38,    6,   39,   40,   41,   42,
-       43,   44,    6,   45,   46,   47,   48,   49,   50,   51,
-       52,    6,   53,   54,   55,   56,    1,    1,    1,    1,
+       35,   36,   37,   38,   39,    6,   40,   41,   42,   43,
+       44,   45,    6,   46,   47,   48,   49,   50,   51,   52,
+       53,    6,   54,   55,   56,   57,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -497,178 +498,188 @@
         1,    1,    1,    1,    1
     } ;
 
-static const YY_CHAR yy_meta[57] =
+static const YY_CHAR yy_meta[58] =
     {   0,
         1,    1,    2,    1,    1,    3,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    4,    4,    1,    1,
-        1,    1,    1,    1,    5,    5,    1,    1,    1,    5,
-        5,    5,    5,    5,    5,    3,    3,    3,    3,    3,
+        1,    1,    1,    1,    5,    5,    1,    1,    1,    3,
+        5,    5,    5,    5,    5,    5,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
-        3,    3,    1,    1,    1,    1
+        3,    3,    3,    1,    1,    1,    1
     } ;
 
-static const flex_int16_t yy_base[259] =
+static const flex_int16_t yy_base[277] =
     {   0,
-        0,    0,  320,  321,   55,   57,  297,    0,    0,  296,
-       53,  321,  321,  295,   50,  321,   49,   47,   57,   52,
-       59,  321,  321,   59,  294,   60,  321,  321,  321,   62,
-      270,   57,   54,  274,   59,  275,   59,   65,  278,  268,
-      262,  264,  274,   57,  262,  264,  262,   53,  321,   74,
-      321,  321,  103,  321,    0,    0,  321,  282,  321,  321,
-      321,  321,  321,  321,   92,  292,    0,  321,   95,   99,
-      118,    0,  280,  321,  321,  321,  279,  321,  278,  265,
-      252,   78,  262,  250,    0,  249,  254,  263,  247,  255,
-        0,  247,  237,  238,  254,  242,  238,  250,   92,  238,
+        0,    0,  339,  340,   56,   58,  316,    0,    0,  315,
+       54,  340,  340,  314,   51,  340,   50,   48,   58,   53,
+       60,  340,  340,   60,  313,   61,  340,  340,  340,   63,
+      288,   56,   54,  292,   60,  293,   54,   63,  296,  286,
+      280,  282,  292,   62,  280,  282,  280,   65,  340,   74,
+      340,  340,  106,  340,    0,    0,  340,  301,  340,  340,
+      340,  340,  340,  340,   97,  311,    0,  340,   99,  104,
+      119,    0,  299,  340,  340,  340,  298,  340,  297,  283,
+      270,   97,  280,  268,    0,  267,  272,  281,  265,  273,
+        0,  265,  255,  256,  272,  260,  256,  268,   95,  272,
 
-      244,  233,  242,  239,  240,  239,  321,  254,    0,  321,
-      128,  264,  258,    0,  126,  136,  106,  138,    0,  321,
-      321,  321,  243,  238,  237,  111,  240,  237,  234,  221,
-      219,    0,  228,  216,  220,  218,  223,  226,    0,  227,
-      225,  210,  208,  207,  207,  219,  217,  221,  210,  202,
-      321,  144,  146,  321,  153,  151,  155,  209,    0,  202,
-      199,  207,  196,  213,    0,  208,    0,  197,  193,  191,
-        0,  190,  192,  198,  192,  189,  188,  200,  199,    0,
-      187,  182,  194,  193,  157,  159,    0,  192,    0,  183,
-      184,  178,    0,    0,    0,  175,  180,  174,  173,  176,
+      255,  261,  250,  259,  256,  257,  256,  340,  272,    0,
+      340,  132,  282,  276,    0,  130,  140,  110,  142,    0,
+      340,  340,  340,  260,  255,  254,  114,  257,  254,  251,
+      238,  236,    0,  245,  233,  237,  235,  240,  243,    0,
+      244,  242,  227,  225,  235,  223,  223,  235,  233,  237,
+      226,  218,  340,  146,  149,  340,  156,  154,  158,  225,
+        0,  218,  215,  223,  212,  229,    0,  224,    0,  213,
+      209,  207,    0,  206,  208,  214,  208,  205,  204,  218,
+      215,  214,    0,  202,  197,  209,  208,  160,  162,    0,
+      207,    0,  198,  199,  193,    0,    0,    0,  190,  195,
 
-      179,  174,  168,  177,  168,  174,    0,  168,  168,  161,
-      161,  174,    0,  162,  161,  166,  163,  170,    0,    0,
-        0,  160,  160,  157,  146,  145,    0,    0,    0,  132,
-      116,   99,  102,    0,  113,  101,    0,    0,  105,   92,
-        0,    0,    0,   79,   80,    0,    0,   81,   62,   32,
-        0,  321,  175,  178,  181,  186,  191,  193
+      189,  188,  191,  194,  189,  184,  182,  191,  182,  188,
+        0,  182,  182,  175,  175,  188,    0,  176,  175,  180,
+      177,  184,    0,  186,    0,    0,  173,  173,  170,  164,
+      176,    0,    0,    0,  175,  165,  155,  159,  159,    0,
+      170,  163,    0,    0,  170,  159,    0,    0,  157,    0,
+      129,  121,    0,  121,    0,  114,  116,   95,  111,  103,
+       89,    0,   84,   82,   77,   73,   51,   20,    0,  340,
+      178,  181,  184,  189,  194,  196
     } ;
 
-static const flex_int16_t yy_def[259] =
+static const flex_int16_t yy_def[277] =
     {   0,
-      252,    1,  252,  252,  252,  252,  252,  253,  254,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  252,  252,
-      252,  252,  252,  252,  255,  254,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  256,  257,  252,  252,  252,
-      252,  258,  252,  252,  252,  252,  252,  252,  252,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
+      270,    1,  270,  270,  270,  270,  270,  271,  272,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  270,  270,
+      270,  270,  270,  270,  273,  272,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  274,  275,  270,  270,  270,
+      270,  276,  270,  270,  270,  270,  270,  270,  270,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
 
-      254,  254,  254,  254,  254,  254,  252,  252,  255,  252,
-      252,  256,  256,  257,  252,  252,  252,  252,  258,  252,
-      252,  252,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      252,  252,  252,  252,  252,  252,  252,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  252,  252,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
+      272,  272,  272,  272,  272,  272,  272,  270,  270,  273,
+      270,  270,  274,  274,  275,  270,  270,  270,  270,  276,
+      270,  270,  270,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  270,  270,  270,  270,  270,  270,  270,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  270,  270,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
 
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,  254,  254,  254,  254,  254,  254,  254,  254,  254,
-      254,    0,  252,  252,  252,  252,  252,  252
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
+      272,  272,  272,  272,  272,  272,  272,  272,  272,    0,
+      270,  270,  270,  270,  270,  270
     } ;
 
-static const flex_int16_t yy_nxt[378] =
+static const flex_int16_t yy_nxt[398] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
        14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
        24,   25,   26,   27,    9,    9,   28,   29,   30,    9,
-       31,   32,   33,   34,   35,    9,   36,   37,    9,   38,
-       39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
-        9,    9,   49,   50,   51,   52,   53,   53,   53,   53,
-       58,   61,   63,   65,   65,  251,   69,   66,   70,   70,
-       64,   62,   67,   69,   59,   70,   70,   71,   68,   73,
-       74,   76,   77,   78,   71,   71,   81,   83,   87,  105,
-       79,   84,   71,   91,   93,  107,   85,  106,   88,   82,
+        9,   31,   32,   33,   34,   35,    9,   36,   37,    9,
+       38,   39,   40,   41,   42,   43,   44,   45,   46,   47,
+       48,    9,    9,   49,   50,   51,   52,   53,   53,   53,
+       53,   58,   61,   63,   65,   65,  269,   69,   66,   70,
+       70,   64,   62,   67,   69,   59,   70,   70,   71,   68,
+       73,   74,   76,   77,   78,   71,   81,   71,   83,   91,
+       87,   79,   84,   93,   71,  108,   92,   85,  268,   82,
 
-       92,   89,   72,  100,   53,   53,  101,   94,   65,   65,
-      250,  115,  115,   69,  125,   70,   70,  111,  249,  126,
-      116,  141,  118,  118,   71,  111,  248,  108,  116,  117,
-      247,  117,   71,  246,  118,  118,  245,  142,  143,  152,
-      244,  152,  115,  115,  153,  153,  243,  156,  242,  156,
-      241,  155,  157,  157,  118,  118,  161,  162,  240,  155,
-      153,  153,  153,  153,  185,  239,  185,  157,  157,  186,
-      186,  157,  157,  186,  186,  186,  186,   55,  238,   55,
-       56,   56,   56,  109,  109,  109,  112,  112,  112,  112,
-      112,  114,  237,  114,  114,  114,  119,  119,  236,  235,
+       88,  100,  106,   89,   72,  267,   94,   53,   53,  101,
+      107,  266,  102,   65,   65,  116,  116,  265,   69,  264,
+       70,   70,  112,  263,  117,  142,  119,  119,  109,   71,
+      118,  112,  118,  117,  126,  119,  119,  262,   71,  127,
+      261,  143,  144,  154,  260,  154,  116,  116,  155,  155,
+      259,  158,  258,  158,  257,  157,  159,  159,  119,  119,
+      163,  164,  155,  155,  157,  155,  155,  188,  256,  188,
+      159,  159,  189,  189,  159,  159,  189,  189,  189,  189,
+       55,  255,   55,   56,   56,   56,  110,  110,  110,  113,
+      113,  113,  113,  113,  115,  254,  115,  115,  115,  120,
 
+      120,  253,  252,  251,  250,  249,  248,  247,  246,  245,
+      244,  243,  242,  241,  240,  239,  238,  237,  236,  235,
       234,  233,  232,  231,  230,  229,  228,  227,  226,  225,
       224,  223,  222,  221,  220,  219,  218,  217,  216,  215,
       214,  213,  212,  211,  210,  209,  208,  207,  206,  205,
       204,  203,  202,  201,  200,  199,  198,  197,  196,  195,
-      194,  193,  192,  191,  190,  189,  188,  187,  184,  183,
+      194,  193,  192,  191,  190,  187,  186,  185,  184,  183,
       182,  181,  180,  179,  178,  177,  176,  175,  174,  173,
-      172,  171,  170,  169,  168,  167,  166,  165,  164,  163,
-      160,  159,  158,  154,  113,  151,  150,  149,  148,  147,
-      146,  145,  144,  140,  139,  138,  137,  136,  135,  134,
-      133,  132,  131,  130,  129,  128,  127,  124,  123,  122,
+      172,  171,  170,  169,  168,  167,  166,  165,  162,  161,
+      160,  156,  114,  153,  152,  151,  150,  149,  148,  147,
 
-      121,  120,  113,  110,  104,  103,  102,   99,   98,   97,
-       96,   95,   90,   86,   80,   75,   60,   57,   54,  252,
-        3,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252
+      146,  145,  141,  140,  139,  138,  137,  136,  135,  134,
+      133,  132,  131,  130,  129,  128,  125,  124,  123,  122,
+      121,  114,  111,  105,  104,  103,   99,   98,   97,   96,
+       95,   90,   86,   80,   75,   60,   57,   54,  270,    3,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270
+
     } ;
 
-static const flex_int16_t yy_chk[378] =
+static const flex_int16_t yy_chk[398] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    5,    5,    6,    6,
-       11,   15,   17,   18,   18,  250,   20,   19,   20,   20,
-       17,   15,   19,   21,   11,   21,   21,   20,   19,   24,
-       24,   26,   26,   30,   21,   20,   32,   33,   35,   48,
-       30,   33,   21,   37,   38,   50,   33,   48,   35,   32,
+        1,    1,    1,    1,    1,    1,    1,    5,    5,    6,
+        6,   11,   15,   17,   18,   18,  268,   20,   19,   20,
+       20,   17,   15,   19,   21,   11,   21,   21,   20,   19,
+       24,   24,   26,   26,   30,   21,   32,   20,   33,   37,
+       35,   30,   33,   38,   21,   50,   37,   33,  267,   32,
 
-       37,   35,   20,   44,   53,   53,   44,   38,   65,   65,
-      249,   69,   69,   70,   82,   70,   70,   65,  248,   82,
-       69,   99,  117,  117,   70,   65,  245,   50,   69,   71,
-      244,   71,   70,  240,   71,   71,  239,   99,   99,  111,
-      236,  111,  115,  115,  111,  111,  235,  116,  233,  116,
-      232,  115,  116,  116,  118,  118,  126,  126,  231,  115,
-      152,  152,  153,  153,  155,  230,  155,  156,  156,  155,
-      155,  157,  157,  185,  185,  186,  186,  253,  226,  253,
-      254,  254,  254,  255,  255,  255,  256,  256,  256,  256,
-      256,  257,  225,  257,  257,  257,  258,  258,  224,  223,
+       35,   44,   48,   35,   20,  266,   38,   53,   53,   44,
+       48,  265,   44,   65,   65,   69,   69,  264,   70,  263,
+       70,   70,   65,  261,   69,   99,  118,  118,   50,   70,
+       71,   65,   71,   69,   82,   71,   71,  260,   70,   82,
+      259,   99,   99,  112,  258,  112,  116,  116,  112,  112,
+      257,  117,  256,  117,  254,  116,  117,  117,  119,  119,
+      127,  127,  154,  154,  116,  155,  155,  157,  252,  157,
+      158,  158,  157,  157,  159,  159,  188,  188,  189,  189,
+      271,  251,  271,  272,  272,  272,  273,  273,  273,  274,
+      274,  274,  274,  274,  275,  249,  275,  275,  275,  276,
 
-      222,  218,  217,  216,  215,  214,  212,  211,  210,  209,
-      208,  206,  205,  204,  203,  202,  201,  200,  199,  198,
-      197,  196,  192,  191,  190,  188,  184,  183,  182,  181,
-      179,  178,  177,  176,  175,  174,  173,  172,  170,  169,
-      168,  166,  164,  163,  162,  161,  160,  158,  150,  149,
-      148,  147,  146,  145,  144,  143,  142,  141,  140,  138,
-      137,  136,  135,  134,  133,  131,  130,  129,  128,  127,
-      125,  124,  123,  113,  112,  108,  106,  105,  104,  103,
-      102,  101,  100,   98,   97,   96,   95,   94,   93,   92,
-       90,   89,   88,   87,   86,   84,   83,   81,   80,   79,
+      276,  246,  245,  242,  241,  239,  238,  237,  236,  235,
+      231,  230,  229,  228,  227,  224,  222,  221,  220,  219,
+      218,  216,  215,  214,  213,  212,  210,  209,  208,  207,
+      206,  205,  204,  203,  202,  201,  200,  199,  195,  194,
+      193,  191,  187,  186,  185,  184,  182,  181,  180,  179,
+      178,  177,  176,  175,  174,  172,  171,  170,  168,  166,
+      165,  164,  163,  162,  160,  152,  151,  150,  149,  148,
+      147,  146,  145,  144,  143,  142,  141,  139,  138,  137,
+      136,  135,  134,  132,  131,  130,  129,  128,  126,  125,
+      124,  114,  113,  109,  107,  106,  105,  104,  103,  102,
 
-       77,   73,   66,   58,   47,   46,   45,   43,   42,   41,
-       40,   39,   36,   34,   31,   25,   14,   10,    7,    3,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252,  252,  252,  252,
-      252,  252,  252,  252,  252,  252,  252
+      101,  100,   98,   97,   96,   95,   94,   93,   92,   90,
+       89,   88,   87,   86,   84,   83,   81,   80,   79,   77,
+       73,   66,   58,   47,   46,   45,   43,   42,   41,   40,
+       39,   36,   34,   31,   25,   14,   10,    7,    3,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
+      270,  270,  270,  270,  270,  270,  270
+
     } ;
 
 /* Table of booleans, true if rule could match eol. */
-static const flex_int32_t yy_rule_can_match_eol[93] =
+static const flex_int32_t yy_rule_can_match_eol[94] =
     {   0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,     };
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,     };
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
@@ -697,7 +708,7 @@
 
 */
 #define YY_NO_UNISTD_H 1
-#line 694 "lex.sksl.c"
+#line 705 "lex.sksl.c"
 
 #define INITIAL 0
 
@@ -960,7 +971,7 @@
 #line 30 "sksl.flex"
 
 
-#line 957 "lex.sksl.c"
+#line 968 "lex.sksl.c"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -987,13 +998,13 @@
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 253 )
+				if ( yy_current_state >= 271 )
 					yy_c = yy_meta[yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 			++yy_cp;
 			}
-		while ( yy_current_state != 252 );
+		while ( yy_current_state != 270 );
 		yy_cp = yyg->yy_last_accepting_cpos;
 		yy_current_state = yyg->yy_last_accepting_state;
 
@@ -1198,296 +1209,301 @@
 case 35:
 YY_RULE_SETUP
 #line 100 "sksl.flex"
-{ return SkSL::Token::STRUCT; }
+{ return SkSL::Token::HASSIDEEFFECTS; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 102 "sksl.flex"
-{ return SkSL::Token::LAYOUT; }
+{ return SkSL::Token::STRUCT; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 104 "sksl.flex"
-{ return SkSL::Token::PRECISION; }
+{ return SkSL::Token::LAYOUT; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
 #line 106 "sksl.flex"
-{ return SkSL::Token::IDENTIFIER; }
+{ return SkSL::Token::PRECISION; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
 #line 108 "sksl.flex"
-{ return SkSL::Token::DIRECTIVE; }
+{ return SkSL::Token::IDENTIFIER; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 110 "sksl.flex"
-{ return SkSL::Token::LPAREN; }
+{ return SkSL::Token::DIRECTIVE; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
 #line 112 "sksl.flex"
-{ return SkSL::Token::RPAREN; }
+{ return SkSL::Token::LPAREN; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
 #line 114 "sksl.flex"
-{ return SkSL::Token::LBRACE; }
+{ return SkSL::Token::RPAREN; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
 #line 116 "sksl.flex"
-{ return SkSL::Token::RBRACE; }
+{ return SkSL::Token::LBRACE; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
 #line 118 "sksl.flex"
-{ return SkSL::Token::LBRACKET; }
+{ return SkSL::Token::RBRACE; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
 #line 120 "sksl.flex"
-{ return SkSL::Token::RBRACKET; }
+{ return SkSL::Token::LBRACKET; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
 #line 122 "sksl.flex"
-{ return SkSL::Token::DOT; }
+{ return SkSL::Token::RBRACKET; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
 #line 124 "sksl.flex"
-{ return SkSL::Token::COMMA; }
+{ return SkSL::Token::DOT; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
 #line 126 "sksl.flex"
-{ return SkSL::Token::PLUSPLUS; }
+{ return SkSL::Token::COMMA; }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
 #line 128 "sksl.flex"
-{ return SkSL::Token::MINUSMINUS; }
+{ return SkSL::Token::PLUSPLUS; }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
 #line 130 "sksl.flex"
-{ return SkSL::Token::PLUS; }
+{ return SkSL::Token::MINUSMINUS; }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
 #line 132 "sksl.flex"
-{ return SkSL::Token::MINUS; }
+{ return SkSL::Token::PLUS; }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
 #line 134 "sksl.flex"
-{ return SkSL::Token::STAR; }
+{ return SkSL::Token::MINUS; }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
 #line 136 "sksl.flex"
-{ return SkSL::Token::SLASH; }
+{ return SkSL::Token::STAR; }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
 #line 138 "sksl.flex"
-{ return SkSL::Token::PERCENT; }
+{ return SkSL::Token::SLASH; }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
 #line 140 "sksl.flex"
-{ return SkSL::Token::SHL; }
+{ return SkSL::Token::PERCENT; }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
 #line 142 "sksl.flex"
-{ return SkSL::Token::SHR; }
+{ return SkSL::Token::SHL; }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
 #line 144 "sksl.flex"
-{ return SkSL::Token::BITWISEOR; }
+{ return SkSL::Token::SHR; }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
 #line 146 "sksl.flex"
-{ return SkSL::Token::BITWISEXOR; }
+{ return SkSL::Token::BITWISEOR; }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
 #line 148 "sksl.flex"
-{ return SkSL::Token::BITWISEAND; }
+{ return SkSL::Token::BITWISEXOR; }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
 #line 150 "sksl.flex"
-{ return SkSL::Token::BITWISENOT; }
+{ return SkSL::Token::BITWISEAND; }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
 #line 152 "sksl.flex"
-{ return SkSL::Token::LOGICALOR; }
+{ return SkSL::Token::BITWISENOT; }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
 #line 154 "sksl.flex"
-{ return SkSL::Token::LOGICALXOR; }
+{ return SkSL::Token::LOGICALOR; }
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
 #line 156 "sksl.flex"
-{ return SkSL::Token::LOGICALAND; }
+{ return SkSL::Token::LOGICALXOR; }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
 #line 158 "sksl.flex"
-{ return SkSL::Token::LOGICALNOT; }
+{ return SkSL::Token::LOGICALAND; }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
 #line 160 "sksl.flex"
-{ return SkSL::Token::QUESTION; }
+{ return SkSL::Token::LOGICALNOT; }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
 #line 162 "sksl.flex"
-{ return SkSL::Token::COLON; }
+{ return SkSL::Token::QUESTION; }
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
 #line 164 "sksl.flex"
-{ return SkSL::Token::EQ; }
+{ return SkSL::Token::COLON; }
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
 #line 166 "sksl.flex"
-{ return SkSL::Token::EQEQ; }
+{ return SkSL::Token::EQ; }
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
 #line 168 "sksl.flex"
-{ return SkSL::Token::NEQ; }
+{ return SkSL::Token::EQEQ; }
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
 #line 170 "sksl.flex"
-{ return SkSL::Token::GT; }
+{ return SkSL::Token::NEQ; }
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
 #line 172 "sksl.flex"
-{ return SkSL::Token::LT; }
+{ return SkSL::Token::GT; }
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
 #line 174 "sksl.flex"
-{ return SkSL::Token::GTEQ; }
+{ return SkSL::Token::LT; }
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
 #line 176 "sksl.flex"
-{ return SkSL::Token::LTEQ; }
+{ return SkSL::Token::GTEQ; }
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
 #line 178 "sksl.flex"
-{ return SkSL::Token::PLUSEQ; }
+{ return SkSL::Token::LTEQ; }
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
 #line 180 "sksl.flex"
-{ return SkSL::Token::MINUSEQ; }
+{ return SkSL::Token::PLUSEQ; }
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
 #line 182 "sksl.flex"
-{ return SkSL::Token::STAREQ; }
+{ return SkSL::Token::MINUSEQ; }
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
 #line 184 "sksl.flex"
-{ return SkSL::Token::SLASHEQ; }
+{ return SkSL::Token::STAREQ; }
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
 #line 186 "sksl.flex"
-{ return SkSL::Token::PERCENTEQ; }
+{ return SkSL::Token::SLASHEQ; }
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
 #line 188 "sksl.flex"
-{ return SkSL::Token::SHLEQ; }
+{ return SkSL::Token::PERCENTEQ; }
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
 #line 190 "sksl.flex"
-{ return SkSL::Token::SHREQ; }
+{ return SkSL::Token::SHLEQ; }
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
 #line 192 "sksl.flex"
-{ return SkSL::Token::BITWISEOREQ; }
+{ return SkSL::Token::SHREQ; }
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
 #line 194 "sksl.flex"
-{ return SkSL::Token::BITWISEXOREQ; }
+{ return SkSL::Token::BITWISEOREQ; }
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
 #line 196 "sksl.flex"
-{ return SkSL::Token::BITWISEANDEQ; }
+{ return SkSL::Token::BITWISEXOREQ; }
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
 #line 198 "sksl.flex"
-{ return SkSL::Token::LOGICALOREQ; }
+{ return SkSL::Token::BITWISEANDEQ; }
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
 #line 200 "sksl.flex"
-{ return SkSL::Token::LOGICALXOREQ; }
+{ return SkSL::Token::LOGICALOREQ; }
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
 #line 202 "sksl.flex"
-{ return SkSL::Token::LOGICALANDEQ; }
+{ return SkSL::Token::LOGICALXOREQ; }
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
 #line 204 "sksl.flex"
-{ return SkSL::Token::SEMICOLON; }
+{ return SkSL::Token::LOGICALANDEQ; }
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
 #line 206 "sksl.flex"
-/* line comment */
+{ return SkSL::Token::SEMICOLON; }
 	YY_BREAK
 case 89:
-/* rule 89 can match eol */
 YY_RULE_SETUP
 #line 208 "sksl.flex"
-/* block comment */
+/* line comment */
 	YY_BREAK
 case 90:
 /* rule 90 can match eol */
 YY_RULE_SETUP
 #line 210 "sksl.flex"
-/* whitespace */
+/* block comment */
 	YY_BREAK
 case 91:
+/* rule 91 can match eol */
 YY_RULE_SETUP
 #line 212 "sksl.flex"
-{ return SkSL::Token::INVALID_TOKEN; }
+/* whitespace */
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
 #line 214 "sksl.flex"
+{ return SkSL::Token::INVALID_TOKEN; }
+	YY_BREAK
+case 93:
+YY_RULE_SETUP
+#line 216 "sksl.flex"
 ECHO;
 	YY_BREAK
-#line 1484 "lex.sksl.c"
+#line 1500 "lex.sksl.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1783,7 +1799,7 @@
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 253 )
+			if ( yy_current_state >= 271 )
 				yy_c = yy_meta[yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
@@ -1812,11 +1828,11 @@
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 253 )
+		if ( yy_current_state >= 271 )
 			yy_c = yy_meta[yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 252);
+	yy_is_jam = (yy_current_state == 270);
 
 	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
@@ -2664,7 +2680,7 @@
 
 #define YYTABLES_NAME "yytables"
 
-#line 214 "sksl.flex"
+#line 216 "sksl.flex"
 
 
 int skslwrap(yyscan_t scanner) {
diff --git a/src/sksl/sksl.flex b/src/sksl/sksl.flex
index bbb106c..2dd4225 100644
--- a/src/sksl/sksl.flex
+++ b/src/sksl/sksl.flex
@@ -97,6 +97,8 @@
 
 restrict { return SkSL::Token::RESTRICT; }
 
+sk_has_side_effects { return SkSL::Token::HASSIDEEFFECTS; }
+
 struct { return SkSL::Token::STRUCT; }
 
 layout { return SkSL::Token::LAYOUT; }
diff --git a/src/sksl/sksl_frag.include b/src/sksl/sksl_frag.include
index d65545d..f1192fe 100644
--- a/src/sksl/sksl_frag.include
+++ b/src/sksl/sksl_frag.include
@@ -14,7 +14,7 @@
 layout(builtin=9999) vec4 gl_LastFragColorARM;
 layout(builtin=9999) int gl_SampleMaskIn[1];
 layout(builtin=9999) out int gl_SampleMask[1];
-layout(builtin=9999) vec4 gl_SecondaryFragColorEXT;
+layout(builtin=9999) out vec4 gl_SecondaryFragColorEXT;
 
 layout(location=0,index=0,builtin=10001) out vec4 sk_FragColor;
 
diff --git a/src/sksl/sksl_geom.include b/src/sksl/sksl_geom.include
index 18e779f..e980d6b 100644
--- a/src/sksl/sksl_geom.include
+++ b/src/sksl/sksl_geom.include
@@ -16,9 +16,9 @@
 
 layout(builtin=8) int sk_InvocationID;
 
-void EmitStreamVertex(int stream);
-void EndStreamPrimitive(int stream);
-void EmitVertex();
-void EndPrimitive();
+sk_has_side_effects void EmitStreamVertex(int stream);
+sk_has_side_effects void EndStreamPrimitive(int stream);
+sk_has_side_effects void EmitVertex();
+sk_has_side_effects void EndPrimitive();
 
 )
diff --git a/tests/SkSLGLSLTest.cpp b/tests/SkSLGLSLTest.cpp
index 6151b94..97d7acb 100644
--- a/tests/SkSLGLSLTest.cpp
+++ b/tests/SkSLGLSLTest.cpp
@@ -11,6 +11,13 @@
 
 #if SK_SUPPORT_GPU
 
+// Note that the optimizer will aggressively kill dead code and substitute constants in place of
+// variables, so we have to jump through a few hoops to ensure that the code in these tests has the
+// necessary side-effects to remain live. In some cases we rely on the optimizer not (yet) being
+// smart enough to optimize around certain constructs; as the optimizer gets smarter it will
+// undoubtedly end up breaking some of these tests. That is a good thing, as long as the new code is
+// equivalent!
+
 static void test(skiatest::Reporter* r, const char* src, const SkSL::Program::Settings& settings,
                  const char* expected, SkSL::Program::Inputs* inputs,
                  SkSL::Program::Kind kind = SkSL::Program::kFragment_Kind) {
@@ -57,7 +64,7 @@
          "void main() {"
          "if (sqrt(2) > 5) { sk_FragColor = vec4(0.75); } else { discard; }"
          "int i = 0;"
-         "while (i < 10) sk_FragColor *= 0.5;"
+         "while (i < 10) { sk_FragColor *= 0.5; i++; }"
          "do { sk_FragColor += 0.01; } while (sk_FragColor.x < 0.75);"
          "for (int i = 0; i < 10; i++) {"
          "if (i % 2 == 1) break; else continue;"
@@ -74,7 +81,10 @@
          "        discard;\n"
          "    }\n"
          "    int i = 0;\n"
-         "    while (true) sk_FragColor *= 0.5;\n"
+         "    while (i < 10) {\n"
+         "        sk_FragColor *= 0.5;\n"
+         "        i++;\n"
+         "    }\n"
          "    do {\n"
          "        sk_FragColor += 0.01;\n"
          "    } while (sk_FragColor.x < 0.75);\n"
@@ -105,8 +115,8 @@
          "}\n"
          "void main() {\n"
          "    float x = 10.0;\n"
-         "    bar(10.0);\n"
-         "    sk_FragColor = vec4(10.0);\n"
+         "    bar(x);\n"
+         "    sk_FragColor = vec4(x);\n"
          "}\n");
 }
 
@@ -165,16 +175,16 @@
          "mat3x4 z = x * y;"
          "vec3 v1 = mat3(1) * vec3(1);"
          "vec3 v2 = vec3(1) * mat3(1);"
+         "sk_FragColor = vec4(z[0].x, v1 + v2);"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    mat2x4 x = mat2x4(1.0);\n"
-         "    mat3x2 y = mat3x2(1.0, 0.0, 0.0, 1.0, vec2(2.0, 2.0));\n"
-         "    mat3x4 z = x * y;\n"
+         "    mat3x4 z = mat2x4(1.0) * mat3x2(1.0, 0.0, 0.0, 1.0, vec2(2.0, 2.0));\n"
          "    vec3 v1 = mat3(1.0) * vec3(1.0);\n"
          "    vec3 v2 = vec3(1.0) * mat3(1.0);\n"
+         "    sk_FragColor = vec4(z[0].x, v1 + v2);\n"
          "}\n");
 }
 
@@ -289,16 +299,21 @@
 
 DEF_TEST(SkSLUsesPrecisionModifiers, r) {
     test(r,
-         "void main() { float x = 0.75; highp float y = 1; }",
+         "void main() { float x = 0.75; highp float y = 1; x++; y++;"
+         "sk_FragColor.rg = vec2(x, y); }",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
          "    float x = 0.75;\n"
          "    float y = 1.0;\n"
-         "}\n");    
+         "    x++;\n"
+         "    y++;\n"
+         "    sk_FragColor.xy = vec2(x, y);\n"
+         "}\n");
     test(r,
-         "void main() { float x = 0.75; highp float y = 1; }",
+         "void main() { float x = 0.75; highp float y = 1; x++; y++;"
+         "sk_FragColor.rg = vec2(x, y); }",
          *SkSL::ShaderCapsFactory::UsesPrecisionModifiers(),
          "#version 400\n"
          "precision highp float;\n"
@@ -306,27 +321,29 @@
          "void main() {\n"
          "    float x = 0.75;\n"
          "    highp float y = 1.0;\n"
-         "}\n");    
+         "    x++;\n"
+         "    y++;\n"
+         "    sk_FragColor.xy = vec2(x, y);\n"
+         "}\n");
 }
 
 DEF_TEST(SkSLMinAbs, r) {
     test(r,
          "void main() {"
          "float x = -5;"
-         "x = min(abs(x), 6);"
+         "sk_FragColor.r = min(abs(x), 6);"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    float x = -5.0;\n"
-         "    x = min(abs(-5.0), 6.0);\n"
+         "    sk_FragColor.x = min(abs(-5.0), 6.0);\n"
          "}\n");
 
     test(r,
          "void main() {"
          "float x = -5.0;"
-         "x = min(abs(x), 6.0);"
+         "sk_FragColor.r = min(abs(x), 6.0);"
          "}",
          *SkSL::ShaderCapsFactory::CannotUseMinAndAbsTogether(),
          "#version 400\n"
@@ -334,30 +351,29 @@
          "void main() {\n"
          "    float minAbsHackVar0;\n"
          "    float minAbsHackVar1;\n"
-         "    float x = -5.0;\n"
-         "    x = ((minAbsHackVar0 = abs(-5.0)) < (minAbsHackVar1 = 6.0) ? minAbsHackVar0 : "
-                                                                                "minAbsHackVar1);\n"
+         "    sk_FragColor.x = ((minAbsHackVar0 = abs(-5.0)) < (minAbsHackVar1 = 6.0) ? "
+                                                               "minAbsHackVar0 : minAbsHackVar1);\n"
          "}\n");
 }
 
 DEF_TEST(SkSLNegatedAtan, r) {
     test(r,
-         "void main() { vec2 x = vec2(1, 2); float y = atan(x.x, -(2 * x.y)); }",
+         "void main() { vec2 x = vec2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    vec2 x = vec2(1.0, 2.0);\n"
-         "    float y = atan(x.x, -(2.0 * x.y));\n"
+         "    vec2 x = vec2(sqrt(2.0));\n"
+         "    sk_FragColor.x = atan(x.x, -x.y);\n"
          "}\n");
     test(r,
-         "void main() { vec2 x = vec2(1, 2); float y = atan(x.x, -(2 * x.y)); }",
+         "void main() { vec2 x = vec2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }",
          *SkSL::ShaderCapsFactory::MustForceNegatedAtanParamToFloat(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    vec2 x = vec2(1.0, 2.0);\n"
-         "    float y = atan(x.x, -1.0 * (2.0 * x.y));\n"
+         "    vec2 x = vec2(sqrt(2.0));\n"
+         "    sk_FragColor.x = atan(x.x, -1.0 * x.y);\n"
          "}\n");
 }
 
@@ -377,28 +393,46 @@
     test(r,
          "void main() {"
          "int i1 = 0x0;"
+         "i1++;"
          "int i2 = 0x1234abcd;"
+         "i2++;"
          "int i3 = 0x7fffffff;"
+         "i3++;"
          "int i4 = 0xffffffff;"
+         "i4++;"
          "int i5 = -0xbeef;"
+         "i5++;"
          "uint u1 = 0x0;"
+         "u1++;"
          "uint u2 = 0x1234abcd;"
+         "u2++;"
          "uint u3 = 0x7fffffff;"
+         "u3++;"
          "uint u4 = 0xffffffff;"
+         "u4++;"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
          "    int i1 = 0;\n"
+         "    i1++;\n"
          "    int i2 = 305441741;\n"
+         "    i2++;\n"
          "    int i3 = 2147483647;\n"
+         "    i3++;\n"
          "    int i4 = -1;\n"
+         "    i4++;\n"
          "    int i5 = -48879;\n"
+         "    i5++;\n"
          "    uint u1 = 0u;\n"
+         "    u1++;\n"
          "    uint u2 = 305441741u;\n"
+         "    u2++;\n"
          "    uint u3 = 2147483647u;\n"
+         "    u3++;\n"
          "    uint u4 = 4294967295u;\n"
+         "    u4++;\n"
          "}\n");
 }
 
@@ -438,29 +472,29 @@
 
 DEF_TEST(SkSLDerivatives, r) {
     test(r,
-         "void main() { float x = dFdx(1); }",
+         "void main() { sk_FragColor.r = dFdx(1); }",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    float x = dFdx(1.0);\n"
+         "    sk_FragColor.x = dFdx(1.0);\n"
          "}\n");
     test(r,
-         "void main() { float x = 1; }",
+         "void main() { sk_FragColor.r = 1; }",
          *SkSL::ShaderCapsFactory::ShaderDerivativeExtensionString(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    float x = 1.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
          "}\n");
     test(r,
-         "void main() { float x = dFdx(1); }",
+         "void main() { sk_FragColor.r = dFdx(1); }",
          *SkSL::ShaderCapsFactory::ShaderDerivativeExtensionString(),
          "#version 400\n"
          "#extension GL_OES_standard_derivatives : require\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    float x = dFdx(1.0);\n"
+         "    sk_FragColor.x = dFdx(1.0);\n"
          "}\n");
 }
 
@@ -468,76 +502,121 @@
     test(r,
          "void main() {"
          "float f_add = 32 + 2;"
+         "sk_FragColor.r = f_add;"
          "float f_sub = 32 - 2;"
+         "sk_FragColor.r = f_sub;"
          "float f_mul = 32 * 2;"
+         "sk_FragColor.r = f_mul;"
          "float f_div = 32 / 2;"
+         "sk_FragColor.r = f_div;"
          "float mixed = (12 > 2.0) ? (10 * 2 / 5 + 18 - 3) : 0;"
+         "sk_FragColor.r = mixed;"
          "int i_add = 32 + 2;"
+         "sk_FragColor.r = i_add;"
          "int i_sub = 32 - 2;"
+         "sk_FragColor.r = i_sub;"
          "int i_mul = 32 * 2;"
+         "sk_FragColor.r = i_mul;"
          "int i_div = 32 / 2;"
+         "sk_FragColor.r = i_div;"
          "int i_or = 12 | 6;"
+         "sk_FragColor.r = i_or;"
          "int i_and = 254 & 7;"
+         "sk_FragColor.r = i_and;"
          "int i_xor = 2 ^ 7;"
+         "sk_FragColor.r = i_xor;"
          "int i_shl = 1 << 4;"
+         "sk_FragColor.r = i_shl;"
          "int i_shr = 128 >> 2;"
+         "sk_FragColor.r = i_shr;"
          "bool gt_it = 6 > 5;"
+         "sk_FragColor.r = true ? 1 : 0;"
          "bool gt_if = 6 > 6;"
+         "sk_FragColor.r = gt_if ? 1 : 0;"
          "bool gt_ft = 6.0 > 5.0;"
+         "sk_FragColor.r = gt_ft ? 1 : 0;"
          "bool gt_ff = 6.0 > 6.0;"
+         "sk_FragColor.r = gt_ff ? 1 : 0;"
          "bool gte_it = 6 >= 6;"
+         "sk_FragColor.r = gte_it ? 1 : 0;"
          "bool gte_if = 6 >= 7;"
+         "sk_FragColor.r = gte_if ? 1 : 0;"
          "bool gte_ft = 6.0 >= 6.0;"
+         "sk_FragColor.r = gte_ft ? 1 : 0;"
          "bool gte_ff = 6.0 >= 7.0;"
+         "sk_FragColor.r = gte_ff ? 1 : 0;"
          "bool lte_it = 6 <= 6;"
+         "sk_FragColor.r = lte_it ? 1 : 0;"
          "bool lte_if = 6 <= 5;"
+         "sk_FragColor.r = lte_if ? 1 : 0;"
          "bool lte_ft = 6.0 <= 6.0;"
+         "sk_FragColor.r = lte_ft ? 1 : 0;"
          "bool lte_ff = 6.0 <= 5.0;"
+         "sk_FragColor.r = lte_ff ? 1 : 0;"
          "bool or_t = 1 == 1 || 2 == 8;"
+         "sk_FragColor.r = or_t ? 1 : 0;"
          "bool or_f = 1 > 1 || 2 == 8;"
+         "sk_FragColor.r = or_f ? 1 : 0;"
          "bool and_t = 1 == 1 && 2 <= 8;"
+         "sk_FragColor.r = and_t ? 1 : 0;"
          "bool and_f = 1 == 2 && 2 == 8;"
+         "sk_FragColor.r = and_f ? 1 : 0;"
          "bool xor_t = 1 == 1 ^^ 1 != 1;"
+         "sk_FragColor.r = xor_t ? 1 : 0;"
          "bool xor_f = 1 == 1 ^^ 1 == 1;"
+         "sk_FragColor.r = xor_f ? 1 : 0;"
          "int ternary = 10 > 5 ? 10 : 5;"
+         "sk_FragColor.r = ternary;"
+         "sk_FragColor.r = vec4(0.5, 1, 1, 1).x;"
+         "sk_FragColor = vec4(vec2(1), vec2(2, 3)) + vec4(5, 6, 7, 8);"
+         "sk_FragColor = vec4(8, vec3(10)) - vec4(1);"
+         "sk_FragColor = vec4(2) * vec4(1, 2, 3, 4);"
+         "sk_FragColor = vec4(12) / vec4(1, 2, 3, 4);"
+         "sk_FragColor.r = (vec4(12) / vec4(1, 2, 3, 4)).y;"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    float f_add = 34.0;\n"
-         "    float f_sub = 30.0;\n"
-         "    float f_mul = 64.0;\n"
-         "    float f_div = 16.0;\n"
-         "    float mixed = 19.0;\n"
-         "    int i_add = 34;\n"
-         "    int i_sub = 30;\n"
-         "    int i_mul = 64;\n"
-         "    int i_div = 16;\n"
-         "    int i_or = 14;\n"
-         "    int i_and = 6;\n"
-         "    int i_xor = 5;\n"
-         "    int i_shl = 16;\n"
-         "    int i_shr = 32;\n"
-         "    bool gt_it = true;\n"
-         "    bool gt_if = false;\n"
-         "    bool gt_ft = true;\n"
-         "    bool gt_ff = false;\n"
-         "    bool gte_it = true;\n"
-         "    bool gte_if = false;\n"
-         "    bool gte_ft = true;\n"
-         "    bool gte_ff = false;\n"
-         "    bool lte_it = true;\n"
-         "    bool lte_if = false;\n"
-         "    bool lte_ft = true;\n"
-         "    bool lte_ff = false;\n"
-         "    bool or_t = true;\n"
-         "    bool or_f = false;\n"
-         "    bool and_t = true;\n"
-         "    bool and_f = false;\n"
-         "    bool xor_t = true;\n"
-         "    bool xor_f = false;\n"
-         "    int ternary = 10;\n"
+         "    sk_FragColor.x = 34.0;\n"
+         "    sk_FragColor.x = 30.0;\n"
+         "    sk_FragColor.x = 64.0;\n"
+         "    sk_FragColor.x = 16.0;\n"
+         "    sk_FragColor.x = 19.0;\n"
+         "    sk_FragColor.x = 34.0;\n"
+         "    sk_FragColor.x = 30.0;\n"
+         "    sk_FragColor.x = 64.0;\n"
+         "    sk_FragColor.x = 16.0;\n"
+         "    sk_FragColor.x = 14.0;\n"
+         "    sk_FragColor.x = 6.0;\n"
+         "    sk_FragColor.x = 5.0;\n"
+         "    sk_FragColor.x = 16.0;\n"
+         "    sk_FragColor.x = 32.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 1.0;\n"
+         "    sk_FragColor.x = 0.0;\n"
+         "    sk_FragColor.x = 10.0;\n"
+         "    sk_FragColor.x = 0.5;\n"
+         "    sk_FragColor = vec4(6.0, 7.0, 9.0, 11.0);\n"
+         "    sk_FragColor = vec4(7.0, 9.0, 9.0, 9.0);\n"
+         "    sk_FragColor = vec4(2.0, 4.0, 6.0, 8.0);\n"
+         "    sk_FragColor = vec4(12.0, 6.0, 4.0, 3.0);\n"
+         "    sk_FragColor.x = 6.0;\n"
          "}\n");
 }
 
@@ -549,40 +628,34 @@
          "if (2 > 1) x = 2; else x = 3;"
          "if (1 > 2) x = 4; else x = 5;"
          "if (false) x = 6;"
+         "sk_FragColor.r = x;"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    int x;\n"
-         "    x = 1;\n"
-         "    x = 2;\n"
-         "    x = 5;\n"
-         "    {\n"
-         "    }\n"
+         "    sk_FragColor.x = 5.0;\n"
          "}\n");
 }
 
 DEF_TEST(SkSLCaps, r) {
     test(r,
          "void main() {"
-         "int x;"
+         "int x = 0;"
+         "int y = 0;"
+         "int z = 0;"
+         "int w = 0;"
          "if (sk_Caps.externalTextureSupport) x = 1;"
-         "if (sk_Caps.fbFetchSupport) x = 2;"
-         "if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.texelFetchSupport) x = 3;"
-         "if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.canUseAnyFunctionInShader) x = 4;"
+         "if (sk_Caps.fbFetchSupport) y = 1;"
+         "if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.texelFetchSupport) z = 1;"
+         "if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.canUseAnyFunctionInShader) w = 1;"
+         "sk_FragColor = vec4(x, y, z, w);"
          "}",
          *SkSL::ShaderCapsFactory::VariousCaps(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    int x;\n"
-         "    x = 1;\n"
-         "    {\n"
-         "    }\n"
-         "    x = 3;\n"
-         "    {\n"
-         "    }\n"
+         "    sk_FragColor = vec4(1.0, 0.0, 1.0, 0.0);\n"
          "}\n");
 }
 
@@ -595,6 +668,7 @@
          "vec4 b = texture(two, vec2(0));"
          "vec4 c = texture(one, vec2(0));"
          "vec4 d = texture(two, vec3(0));"
+         "sk_FragColor = vec4(a.x, b.x, c.x, d.x);"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
@@ -606,6 +680,7 @@
          "    vec4 b = texture(two, vec2(0.0));\n"
          "    vec4 c = textureProj(one, vec2(0.0));\n"
          "    vec4 d = textureProj(two, vec3(0.0));\n"
+         "    sk_FragColor = vec4(a.x, b.x, c.x, d.x);\n"
          "}\n");
     test(r,
          "uniform sampler1D one;"
@@ -615,6 +690,7 @@
          "vec4 b = texture(two, vec2(0));"
          "vec4 c = texture(one, vec2(0));"
          "vec4 d = texture(two, vec3(0));"
+         "sk_FragColor = vec4(a.x, b.x, c.x, d.x);"
          "}",
          *SkSL::ShaderCapsFactory::Version110(),
          "#version 110\n"
@@ -625,6 +701,7 @@
          "    vec4 b = texture2D(two, vec2(0.0));\n"
          "    vec4 c = texture1DProj(one, vec2(0.0));\n"
          "    vec4 d = texture2DProj(two, vec3(0.0));\n"
+         "    gl_FragColor = vec4(a.x, b.x, c.x, d.x);\n"
          "}\n");
 }
 
@@ -740,13 +817,14 @@
 DEF_TEST(SkSLArrayTypes, r) {
     test(r,
          "void main() { vec2 x[2] = vec2[2](vec2(1), vec2(2));"
-         "vec2[2] y = vec2[2](vec2(3), vec2(4)); }",
+         "vec2[2] y = vec2[2](vec2(3), vec2(4));"
+         "sk_FragColor = vec4(x[0], y[1]); }",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    vec2 x[2] = vec2[2](vec2(1.0), vec2(2.0));\n"
-         "    vec2[2] y = vec2[2](vec2(3.0), vec2(4.0));\n"
+         "    sk_FragColor = vec4(vec2[2](vec2(1.0), vec2(2.0))[0], "
+                                 "vec2[2](vec2(3.0), vec2(4.0))[1]);\n"
          "}\n");
 }
 
@@ -827,14 +905,13 @@
          "#version 400\n"
          "out vec4 sk_FragColor;\n"
          "void main() {\n"
-         "    float x;\n"
          "    switch (2) {\n"
          "        case 0:\n"
-         "            x = 0.0;\n"
+         "            ;\n"
          "        case 1:\n"
-         "            x = 1.0;\n"
+         "            ;\n"
          "        default:\n"
-         "            x = 2.0;\n"
+         "            ;\n"
          "    }\n"
          "    sk_FragColor = vec4(2.0);\n"
          "}\n");
@@ -903,4 +980,26 @@
          "}\n");
 }
 
+DEF_TEST(SkSLUnusedVars, r) {
+    test(r,
+         "void main() {"
+         "float a = 1, b = 2, c = 3;"
+         "float d = c;"
+         "float e = d;"
+         "b++;"
+         "d++;"
+         "sk_FragColor = vec4(b, b, d, d);"
+         "}",
+        *SkSL::ShaderCapsFactory::Default(),
+         "#version 400\n"
+         "out vec4 sk_FragColor;\n"
+         "void main() {\n"
+         "    float b = 2.0;\n"
+         "    float d = 3.0;\n"
+         "    b++;\n"
+         "    d++;\n"
+         "    sk_FragColor = vec4(b, b, d, d);\n"
+         "}\n");
+}
+
 #endif