refactored SkSL VarDeclaration handling

src/sksl/SkSLSPIRVCodeGenerator.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 "SkSLSPIRVCodeGenerator.h"
 
 #include "string.h"
@@ skipping 2345 matching lines @@
     this->writeInstruction(SpvOpDecorate, type, SpvDecorationBlock, fDecorationBuffer);
     SpvStorageClass_ storageClass = get_storage_class(intf.fVariable.fModifiers);
     SpvId ptrType = this->nextId();
     this->writeInstruction(SpvOpTypePointer, ptrType, storageClass, type, fConstantBuffer);
     this->writeInstruction(SpvOpVariable, ptrType, result, storageClass, fConstantBuffer);
     this->writeLayout(intf.fVariable.fModifiers.fLayout, result);
     fVariableMap[&intf.fVariable] = result;
     return result;
 }
 
-void SPIRVCodeGenerator::writeGlobalVars(const VarDeclaration& decl, std::ostream& out) {
+void SPIRVCodeGenerator::writeGlobalVars(const VarDeclarations& decl, std::ostream& out) {
     for (size_t i = 0; i < decl.fVars.size(); i++) {
-        if (!decl.fVars[i]->fIsReadFrom && !decl.fVars[i]->fIsWrittenTo &&
-                !(decl.fVars[i]->fModifiers.fFlags & (Modifiers::kIn_Flag |
-                                                      Modifiers::kOut_Flag |
-                                                      Modifiers::kUniform_Flag))) {
+        const VarDeclaration& varDecl = decl.fVars[i];
+        const Variable* var = varDecl.fVar;
+        if (!var->fIsReadFrom && !var->fIsWrittenTo &&
+                !(var->fModifiers.fFlags & (Modifiers::kIn_Flag |
+                                            Modifiers::kOut_Flag |
+                                            Modifiers::kUniform_Flag))) {
             // variable is dead and not an input / output var (the Vulkan debug layers complain if
             // we elide an interface var, even if it's dead)
             continue;
         }
         SpvStorageClass_ storageClass;
-        if (decl.fVars[i]->fModifiers.fFlags & Modifiers::kIn_Flag) {
+        if (var->fModifiers.fFlags & Modifiers::kIn_Flag) {
             storageClass = SpvStorageClassInput;
-        } else if (decl.fVars[i]->fModifiers.fFlags & Modifiers::kOut_Flag) {
+        } else if (var->fModifiers.fFlags & Modifiers::kOut_Flag) {
             storageClass = SpvStorageClassOutput;
-        } else if (decl.fVars[i]->fModifiers.fFlags & Modifiers::kUniform_Flag) {
-            if (decl.fVars[i]->fType.kind() == Type::kSampler_Kind) {
+        } else if (var->fModifiers.fFlags & Modifiers::kUniform_Flag) {
+            if (var->fType.kind() == Type::kSampler_Kind) {
                 storageClass = SpvStorageClassUniformConstant;
             } else {
                 storageClass = SpvStorageClassUniform;
             }
         } else {
             storageClass = SpvStorageClassPrivate;
         }
         SpvId id = this->nextId();
-        fVariableMap[decl.fVars[i]] = id;
-        SpvId type = this->getPointerType(decl.fVars[i]->fType, storageClass);
+        fVariableMap[var] = id;
+        SpvId type = this->getPointerType(var->fType, storageClass);
         this->writeInstruction(SpvOpVariable, type, id, storageClass, fConstantBuffer);
-        this->writeInstruction(SpvOpName, id, decl.fVars[i]->fName.c_str(), fNameBuffer);
-        if (decl.fVars[i]->fType.kind() == Type::kMatrix_Kind) {
+        this->writeInstruction(SpvOpName, id, var->fName.c_str(), fNameBuffer);
+        if (var->fType.kind() == Type::kMatrix_Kind) {
             this->writeInstruction(SpvOpMemberDecorate, id, (SpvId) i, SpvDecorationColMajor, 
                                    fDecorationBuffer);
             this->writeInstruction(SpvOpMemberDecorate, id, (SpvId) i, SpvDecorationMatrixStride, 
-                                   (SpvId) decl.fVars[i]->fType.stride(), fDecorationBuffer);
+                                   (SpvId) var->fType.stride(), fDecorationBuffer);
         }
-        if (decl.fValues[i]) {
+        if (varDecl.fValue) {
             ASSERT(!fCurrentBlock);
             fCurrentBlock = -1;
-            SpvId value = this->writeExpression(*decl.fValues[i], fGlobalInitializersBuffer);
+            SpvId value = this->writeExpression(*varDecl.fValue, fGlobalInitializersBuffer);
             this->writeInstruction(SpvOpStore, id, value, fGlobalInitializersBuffer);
             fCurrentBlock = 0;
         }
-        this->writeLayout(decl.fVars[i]->fModifiers.fLayout, id);
+        this->writeLayout(var->fModifiers.fLayout, id);
     }
 }
 
-void SPIRVCodeGenerator::writeVarDeclaration(const VarDeclaration& decl, std::ostream& out) {
-    for (size_t i = 0; i < decl.fVars.size(); i++) {
+void SPIRVCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, std::ostream& out) {
+    for (const auto& varDecl : decl.fVars) {
+        const Variable* var = varDecl.fVar;
         SpvId id = this->nextId();
-        fVariableMap[decl.fVars[i]] = id;
-        SpvId type = this->getPointerType(decl.fVars[i]->fType, SpvStorageClassFunction);
+        fVariableMap[var] = id;
+        SpvId type = this->getPointerType(var->fType, SpvStorageClassFunction);
         this->writeInstruction(SpvOpVariable, type, id, SpvStorageClassFunction, fVariableBuffer);
-        this->writeInstruction(SpvOpName, id, decl.fVars[i]->fName.c_str(), fNameBuffer);
-        if (decl.fValues[i]) {
-            SpvId value = this->writeExpression(*decl.fValues[i], out);
+        this->writeInstruction(SpvOpName, id, var->fName.c_str(), fNameBuffer);
+        if (varDecl.fValue) {
+            SpvId value = this->writeExpression(*varDecl.fValue, out);
             this->writeInstruction(SpvOpStore, id, value, out);
         }
     }
 }
 
 void SPIRVCodeGenerator::writeStatement(const Statement& s, std::ostream& out) {
     switch (s.fKind) {
         case Statement::kBlock_Kind:
             this->writeBlock((Block&) s, out);
             break;
         case Statement::kExpression_Kind:
             this->writeExpression(*((ExpressionStatement&) s).fExpression, out);
             break;
         case Statement::kReturn_Kind: 
             this->writeReturnStatement((ReturnStatement&) s, out);
             break;
-        case Statement::kVarDeclaration_Kind:
-            this->writeVarDeclaration(*((VarDeclarationStatement&) s).fDeclaration, out);
+        case Statement::kVarDeclarations_Kind:
+            this->writeVarDeclarations(*((VarDeclarationsStatement&) s).fDeclaration, out);
             break;
         case Statement::kIf_Kind:
             this->writeIfStatement((IfStatement&) s, out);
             break;
         case Statement::kFor_Kind:
             this->writeForStatement((ForStatement&) s, out);
             break;
         case Statement::kBreak_Kind:
             this->writeInstruction(SpvOpBranch, fBreakTarget.top(), out);
             break;
@@ skipping 103 matching lines @@
             InterfaceBlock& intf = (InterfaceBlock&) *program.fElements[i];
             SpvId id = this->writeInterfaceBlock(intf);
             if ((intf.fVariable.fModifiers.fFlags & Modifiers::kIn_Flag) ||
                 (intf.fVariable.fModifiers.fFlags & Modifiers::kOut_Flag)) {
                 interfaceVars.push_back(id);
             }
         }
     }
     for (size_t i = 0; i < program.fElements.size(); i++) {
         if (program.fElements[i]->fKind == ProgramElement::kVar_Kind) {
-            this->writeGlobalVars(((VarDeclaration&) *program.fElements[i]), body);
+            this->writeGlobalVars(((VarDeclarations&) *program.fElements[i]), body);
         }
     }
     for (size_t i = 0; i < program.fElements.size(); i++) {
         if (program.fElements[i]->fKind == ProgramElement::kFunction_Kind) {
             this->writeFunction(((FunctionDefinition&) *program.fElements[i]), body);
         }
     }
     const FunctionDeclaration* main = nullptr;
     for (auto entry : fFunctionMap) {
         if (entry.first->fName == "main") {
@@ skipping 53 matching lines @@
     this->writeWord(SpvVersion, out);
     this->writeWord(SKSL_MAGIC, out);
     std::stringstream buffer;
     this->writeInstructions(program, buffer);
     this->writeWord(fIdCount, out);
     this->writeWord(0, out); // reserved, always zero
     out << buffer.str();
 }
 
 }