added basic dataflow analysis to skslc

src/sksl/SkSLContext.h

 /*
  * 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_CONTEXT
 #define SKSL_CONTEXT
 
 #include "ir/SkSLType.h"
+#include "ir/SkSLExpression.h"
 
 namespace SkSL {
 
 /**
  * Contains compiler-wide objects, which currently means the core types.
  */
 class Context {
 public:
     Context()
     : fVoid_Type(new Type("void"))
@@ skipping 85 matching lines @@
                                    fVec4_Type.get() }))
     , fGVec_Type(new Type("$gvec"))
     , fGVec2_Type(new Type("$gvec2"))
     , fGVec3_Type(new Type("$gvec3"))
     , fGVec4_Type(new Type("$gvec4", static_type(*fVec4_Type)))
     , fDVec_Type(new Type("$dvec"))
     , fIVec_Type(new Type("$ivec"))
     , fUVec_Type(new Type("$uvec"))
     , fBVec_Type(new Type("$bvec", { fBVec2_Type.get(), fBVec2_Type.get(), fBVec3_Type.get(), 
                                      fBVec4_Type.get() }))
-    , fInvalid_Type(new Type("<INVALID>")) {}
+    , fInvalid_Type(new Type("<INVALID>"))
+    , fDefined_Expression(new Defined(*fInvalid_Type)) {}
 
     static std::vector<const Type*> static_type(const Type& t) {
         return { &t, &t, &t, &t };   
     }
 
     const std::unique_ptr<Type> fVoid_Type;
 
     const std::unique_ptr<Type> fDouble_Type;
     const std::unique_ptr<Type> fDVec2_Type;
     const std::unique_ptr<Type> fDVec3_Type;
@@ skipping 87 matching lines @@
     const std::unique_ptr<Type> fGVec2_Type;
     const std::unique_ptr<Type> fGVec3_Type;
     const std::unique_ptr<Type> fGVec4_Type;
     const std::unique_ptr<Type> fDVec_Type;
     const std::unique_ptr<Type> fIVec_Type;
     const std::unique_ptr<Type> fUVec_Type;
 
     const std::unique_ptr<Type> fBVec_Type;
 
     const std::unique_ptr<Type> fInvalid_Type;
+
+    // dummy expression used to mark that a variable has a value during dataflow analysis (when it 
+    // could have several different values, or the analyzer is otherwise unable to assign it a
+    // specific expression)
+    const std::unique_ptr<Expression> fDefined_Expression;
+
+private:    
+    class Defined : public Expression {
+    public:
+        Defined(const Type& type)
+        : INHERITED(Position(), kDefined_Kind, type) {}
+
+        virtual std::string description() const override {
+            return "<defined>";
+        }
+
+        typedef Expression INHERITED;
+    };
 };
 
 } // namespace
 
 #endif