added basic dataflow analysis to skslc

src/sksl/SkSLIRGenerator.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #include "SkSLIRGenerator.h"
 
 #include "limits.h"
@@ skipping 24 matching lines @@
 #include "ir/SkSLInterfaceBlock.h"
 #include "ir/SkSLIntLiteral.h"
 #include "ir/SkSLLayout.h"
 #include "ir/SkSLPostfixExpression.h"
 #include "ir/SkSLPrefixExpression.h"
 #include "ir/SkSLReturnStatement.h"
 #include "ir/SkSLSwizzle.h"
 #include "ir/SkSLTernaryExpression.h"
 #include "ir/SkSLUnresolvedFunction.h"
 #include "ir/SkSLVariable.h"
-#include "ir/SkSLVarDeclaration.h"
-#include "ir/SkSLVarDeclarationStatement.h"
+#include "ir/SkSLVarDeclarations.h"
+#include "ir/SkSLVarDeclarationsStatement.h"
 #include "ir/SkSLVariableReference.h"
 #include "ir/SkSLWhileStatement.h"
 
 namespace SkSL {
 
 class AutoSymbolTable {
 public:
     AutoSymbolTable(IRGenerator* ir) 
     : fIR(ir)
     , fPrevious(fIR->fSymbolTable) {
         fIR->pushSymbolTable();
     }
 
     ~AutoSymbolTable() {
         fIR->popSymbolTable();
         ASSERT(fPrevious == fIR->fSymbolTable);
     }
 
     IRGenerator* fIR;
     std::shared_ptr<SymbolTable> fPrevious;
 };
 
+class AutoLoopLevel {
+public:
+    AutoLoopLevel(IRGenerator* ir) 
+    : fIR(ir) {
+        fIR->fLoopLevel++;
+    }
+
+    ~AutoLoopLevel() {
+        fIR->fLoopLevel--;
+    }
+
+    IRGenerator* fIR;
+};
+
 IRGenerator::IRGenerator(const Context* context, std::shared_ptr<SymbolTable> symbolTable, 
                          ErrorReporter& errorReporter)
 : fContext(*context)
 , fCurrentFunction(nullptr)
 , fSymbolTable(std::move(symbolTable))
+, fLoopLevel(0)
 , fErrors(errorReporter) {}
 
 void IRGenerator::pushSymbolTable() {
     fSymbolTable.reset(new SymbolTable(std::move(fSymbolTable), fErrors));
 }
 
 void IRGenerator::popSymbolTable() {
     fSymbolTable = fSymbolTable->fParent;
 }
 
@@ skipping 144 matching lines @@
         ifFalse = this->convertStatement(*s.fIfFalse);
         if (!ifFalse) {
             return nullptr;
         }
     }
     return std::unique_ptr<Statement>(new IfStatement(s.fPosition, std::move(test), 
                                                       std::move(ifTrue), std::move(ifFalse)));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertFor(const ASTForStatement& f) {
+    AutoLoopLevel level(this);
     AutoSymbolTable table(this);
-    std::unique_ptr<Statement> initializer = this->convertStatement(*f.fInitializer);
-    if (!initializer) {
-        return nullptr;
+    std::unique_ptr<Statement> initializer;
+    if (f.fInitializer) {
+        initializer = this->convertStatement(*f.fInitializer);
+        if (!initializer) {
+            return nullptr;
+        }
     }
-    std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*f.fTest), 
-                                                    *fContext.fBool_Type);
-    if (!test) {
-        return nullptr;
+    std::unique_ptr<Expression> test;
+    if (f.fTest) {
+        test = this->coerce(this->convertExpression(*f.fTest), *fContext.fBool_Type);
+        if (!test) {
+            return nullptr;
+        }
     }
-    std::unique_ptr<Expression> next = this->convertExpression(*f.fNext);
-    if (!next) {
-        return nullptr;
+    std::unique_ptr<Expression> next;
+    if (f.fNext) {
+        next = this->convertExpression(*f.fNext);
+        if (!next) {
+            return nullptr;
+        }
+        this->checkValid(*next);
     }
-    this->checkValid(*next);
     std::unique_ptr<Statement> statement = this->convertStatement(*f.fStatement);
     if (!statement) {
         return nullptr;
     }
     return std::unique_ptr<Statement>(new ForStatement(f.fPosition, std::move(initializer), 
                                                        std::move(test), std::move(next),
                                                        std::move(statement), fSymbolTable));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertWhile(const ASTWhileStatement& w) {
+    AutoLoopLevel level(this);
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*w.fTest), 
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
     }
     std::unique_ptr<Statement> statement = this->convertStatement(*w.fStatement);
     if (!statement) {
         return nullptr;
     }
     return std::unique_ptr<Statement>(new WhileStatement(w.fPosition, std::move(test),
                                                          std::move(statement)));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertDo(const ASTDoStatement& d) {
+    AutoLoopLevel level(this);
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*d.fTest),
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
     }
     std::unique_ptr<Statement> statement = this->convertStatement(*d.fStatement);
     if (!statement) {
         return nullptr;
     }
     return std::unique_ptr<Statement>(new DoStatement(d.fPosition, std::move(statement), 
@@ skipping 29 matching lines @@
     } else {
         if (fCurrentFunction->fReturnType != *fContext.fVoid_Type) {
             fErrors.error(r.fPosition, "expected function to return '" +
                                        fCurrentFunction->fReturnType.description() + "'");
         }
         return std::unique_ptr<Statement>(new ReturnStatement(r.fPosition));
     }
 }
 
 std::unique_ptr<Statement> IRGenerator::convertBreak(const ASTBreakStatement& b) {
-    return std::unique_ptr<Statement>(new BreakStatement(b.fPosition));
+    if (fLoopLevel > 0) {
+        return std::unique_ptr<Statement>(new BreakStatement(b.fPosition));
+    } else {
+        fErrors.error(b.fPosition, "break statement must be inside a loop");
+        return nullptr;
+    }
 }
 
 std::unique_ptr<Statement> IRGenerator::convertContinue(const ASTContinueStatement& c) {
-    return std::unique_ptr<Statement>(new ContinueStatement(c.fPosition));
+    if (fLoopLevel > 0) {
+        return std::unique_ptr<Statement>(new ContinueStatement(c.fPosition));
+    } else {
+        fErrors.error(c.fPosition, "continue statement must be inside a loop");
+        return nullptr;
+    }
 }
 
 std::unique_ptr<Statement> IRGenerator::convertDiscard(const ASTDiscardStatement& d) {
     return std::unique_ptr<Statement>(new DiscardStatement(d.fPosition));
 }
 
 static const Type& expand_generics(const Type& type, int i) {
     if (type.kind() == Type::kGeneric_Kind) {
         return *type.coercibleTypes()[i];
     }
@@ skipping 958 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }