Revert of Reduced skslc memory consumption

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()
-    : fInvalid_Type(new Type("<INVALID>"))
-    , fVoid_Type(new Type("void"))
+    : fVoid_Type(new Type("void"))
     , fDouble_Type(new Type("double", true))
     , fDVec2_Type(new Type("dvec2", *fDouble_Type, 2))
     , fDVec3_Type(new Type("dvec3", *fDouble_Type, 3))
     , fDVec4_Type(new Type("dvec4", *fDouble_Type, 4))
     , fFloat_Type(new Type("float", true, { fDouble_Type.get() }))
     , fVec2_Type(new Type("vec2", *fFloat_Type, 2))
     , fVec3_Type(new Type("vec3", *fFloat_Type, 3))
     , fVec4_Type(new Type("vec4", *fFloat_Type, 4))
     , fUInt_Type(new Type("uint", true, { fFloat_Type.get(), fDouble_Type.get() }))
     , fUVec2_Type(new Type("uvec2", *fUInt_Type, 2))
@@ skipping 64 matching lines @@
                                            fVec4_Type.get() }))
     , fGenDType_Type(new Type("$genDType", { fDouble_Type.get(), fDVec2_Type.get(), 
                                              fDVec3_Type.get(), fDVec4_Type.get() }))
     , fGenIType_Type(new Type("$genIType", { fInt_Type.get(), fIVec2_Type.get(), fIVec3_Type.get(), 
                                              fIVec4_Type.get() }))
     , fGenUType_Type(new Type("$genUType", { fUInt_Type.get(), fUVec2_Type.get(), fUVec3_Type.get(), 
                                              fUVec4_Type.get() }))
     , fGenBType_Type(new Type("$genBType", { fBool_Type.get(), fBVec2_Type.get(), fBVec3_Type.get(), 
                                              fBVec4_Type.get() }))
     , fMat_Type(new Type("$mat"))
-    , fVec_Type(new Type("$vec", { fInvalid_Type.get(), fVec2_Type.get(), fVec3_Type.get(),
+    , fVec_Type(new Type("$vec", { fVec2_Type.get(), fVec2_Type.get(), fVec3_Type.get(),
                                    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", { fInvalid_Type.get(), fDVec2_Type.get(), fDVec3_Type.get(),
-                                     fDVec4_Type.get() }))
-    , fIVec_Type(new Type("$ivec", { fInvalid_Type.get(), fIVec2_Type.get(), fIVec3_Type.get(),
-                                     fIVec4_Type.get() }))
-    , fUVec_Type(new Type("$uvec", { fInvalid_Type.get(), fUVec2_Type.get(), fUVec3_Type.get(),
-                                     fUVec4_Type.get() }))
-    , fBVec_Type(new Type("$bvec", { fInvalid_Type.get(), fBVec2_Type.get(), fBVec3_Type.get(), 
+    , 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>"))
     , 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> fInvalid_Type;
     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;
     const std::unique_ptr<Type> fDVec4_Type;
 
     const std::unique_ptr<Type> fFloat_Type;
     const std::unique_ptr<Type> fVec2_Type;
     const std::unique_ptr<Type> fVec3_Type;
@@ skipping 81 matching lines @@
     const std::unique_ptr<Type> fGVec_Type;
     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