text: //
  // Copyright (C) 2017-2018 Google, Inc.
  // Copyright (C) 2017 LunarG, Inc.
  //
  // All rights reserved.
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions
  // are met:
  //
  //    Redistributions of source code must retain the above copyright
  //    notice, this list of conditions and the following disclaimer.
  //
  //    Redistributions in binary form must reproduce the above
  //    copyright notice, this list of conditions and the following
  //    disclaimer in the documentation and/or other materials provided
  //    with the distribution.
  //
  //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
  //    contributors may be used to endorse or promote products derived
  //    from this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  // POSSIBILITY OF SUCH DAMAGE.
  //
  
  #include "hlslParseHelper.h"
  #include "hlslScanContext.h"
  #include "hlslGrammar.h"
  #include "hlslAttributes.h"
  
  #include "../glslang/Include/Common.h"
  #include "../glslang/MachineIndependent/Scan.h"
  #include "../glslang/MachineIndependent/preprocessor/PpContext.h"
  
  #include "../glslang/OSDependent/osinclude.h"
  
  #include <algorithm>
  #include <functional>
  #include <cctype>
  #include <array>
  #include <set>
  
  namespace glslang {
  
  HlslParseContext::HlslParseContext(TSymbolTable& symbolTable, TIntermediate& interm, bool parsingBuiltins,
                                     int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language,
                                     TInfoSink& infoSink,
                                     const TString sourceEntryPointName,
                                     bool forwardCompatible, EShMessages messages) :
      TParseContextBase(symbolTable, interm, parsingBuiltins, version, profile, spvVersion, language, infoSink,
                        forwardCompatible, messages, &sourceEntryPointName),
      annotationNestingLevel(0),
      inputPatch(nullptr),
      nextInLocation(0), nextOutLocation(0),
      entryPointFunction(nullptr),
      entryPointFunctionBody(nullptr),
      gsStreamOutput(nullptr),
      clipDistanceOutput(nullptr),
      cullDistanceOutput(nullptr),
      clipDistanceInput(nullptr),
      cullDistanceInput(nullptr),
      parsingEntrypointParameters(false)
  {
      globalUniformDefaults.clear();
      globalUniformDefaults.layoutMatrix = ElmRowMajor;
      globalUniformDefaults.layoutPacking = ElpStd140;
  
      globalBufferDefaults.clear();
      globalBufferDefaults.layoutMatrix = ElmRowMajor;
      globalBufferDefaults.layoutPacking = ElpStd430;
  
      globalInputDefaults.clear();
      globalOutputDefaults.clear();
  
      clipSemanticNSizeIn.fill(0);
      cullSemanticNSizeIn.fill(0);
      clipSemanticNSizeOut.fill(0);
      cullSemanticNSizeOut.fill(0);
  
      // "Shaders in the transform
      // feedback capturing mode have an initial global default of
      //     layout(xfb_buffer = 0) out;"
      if (language == EShLangVertex ||
          language == EShLangTessControl ||
          language == EShLangTessEvaluation ||
          language == EShLangGeometry)
          globalOutputDefaults.layoutXfbBuffer = 0;
  
      if (language == EShLangGeometry)
          globalOutputDefaults.layoutStream = 0;
  }
  
  HlslParseContext::~HlslParseContext()
  {
  }
  
  void HlslParseContext::initializeExtensionBehavior()
  {
      TParseContextBase::initializeExtensionBehavior();
  
      // HLSL allows #line by default.
      extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive] = EBhEnable;
  }
  
  void HlslParseContext::setLimits(const TBuiltInResource& r)
  {
      resources = r;
      intermediate.setLimits(resources);
  }
  
  //
  // Parse an array of strings using the parser in HlslRules.
  //
  // Returns true for successful acceptance of the shader, false if any errors.
  //
  bool HlslParseContext::parseShaderStrings(TPpContext& ppContext, TInputScanner& input, bool versionWillBeError)
  {
      currentScanner = &input;
      ppContext.setInput(input, versionWillBeError);
  
      HlslScanContext scanContext(*this, ppContext);
      HlslGrammar grammar(scanContext, *this);
      if (!grammar.parse()) {
          // Print a message formated such that if you click on the message it will take you right to
          // the line through most UIs.
          const glslang::TSourceLoc& sourceLoc = input.getSourceLoc();
          infoSink.info << sourceLoc.getFilenameStr() << "(" << sourceLoc.line << "): error at column " << sourceLoc.column
                        << ", HLSL parsing failed.\n";
          ++numErrors;
          return false;
      }
  
      finish();
  
      return numErrors == 0;
  }
  
  //
  // Return true if this l-value node should be converted in some manner.
  // For instance: turning a load aggregate into a store in an l-value.
  //
  bool HlslParseContext::shouldConvertLValue(const TIntermNode* node) const
  {
      if (node == nullptr || node->getAsTyped() == nullptr)
          return false;
  
      const TIntermAggregate* lhsAsAggregate = node->getAsAggregate();
      const TIntermBinary* lhsAsBinary = node->getAsBinaryNode();
  
      // If it's a swizzled/indexed aggregate, look at the left node instead.
      if (lhsAsBinary != nullptr &&
          (lhsAsBinary->getOp() == EOpVectorSwizzle || lhsAsBinary->getOp() == EOpIndexDirect))
          lhsAsAggregate = lhsAsBinary->getLeft()->getAsAggregate();
      if (lhsAsAggregate != nullptr && lhsAsAggregate->getOp() == EOpImageLoad)
          return true;
  
      return false;
  }
  
  void HlslParseContext::growGlobalUniformBlock(const TSourceLoc& loc, TType& memberType, const TString& memberName,
                                                TTypeList* newTypeList)
  {
      newTypeList = nullptr;
      correctUniform(memberType.getQualifier());
      if (memberType.isStruct()) {
          auto it = ioTypeMap.find(memberType.getStruct());
          if (it != ioTypeMap.end() && it->second.uniform)
              newTypeList = it->second.uniform;
      }
      TParseContextBase::growGlobalUniformBlock(loc, memberType, memberName, newTypeList);
  }
  
  //
  // Return a TLayoutFormat corresponding to the given texture type.
  //
  TLayoutFormat HlslParseContext::getLayoutFromTxType(const TSourceLoc& loc, const TType& txType)
  {
      if (txType.isStruct()) {
          // TODO: implement.
          error(loc, "unimplemented: structure type in image or buffer", "", "");
          return ElfNone;
      }
  
      const int components = txType.getVectorSize();
      const TBasicType txBasicType = txType.getBasicType();
  
      const auto selectFormat = [this,&components](TLayoutFormat v1, TLayoutFormat v2, TLayoutFormat v4) -> TLayoutFormat {
          if (intermediate.getNoStorageFormat())
              return ElfNone;
  
          return components == 1 ? v1 :
                 components == 2 ? v2 : v4;
      };
  
      switch (txBasicType) {
      case EbtFloat: return selectFormat(ElfR32f,  ElfRg32f,  ElfRgba32f);
      case EbtInt:   return selectFormat(ElfR32i,  ElfRg32i,  ElfRgba32i);
      case EbtUint:  return selectFormat(ElfR32ui, ElfRg32ui, ElfRgba32ui);
      default:
          error(loc, "unknown basic type in image format", "", "");
          return ElfNone;
      }
  }
  
  //
  // Both test and if necessary, spit out an error, to see if the node is really
  // an l-value that can be operated on this way.
  //
  // Returns true if there was an error.
  //
  bool HlslParseContext::lValueErrorCheck(const TSourceLoc& loc, const char* op, TIntermTyped* node)
  {
      if (shouldConvertLValue(node)) {
          // if we're writing to a texture, it must be an RW form.
  
          TIntermAggregate* lhsAsAggregate = node->getAsAggregate();
          TIntermTyped* object = lhsAsAggregate->getSequence()[0]->getAsTyped();
  
          if (!object->getType().getSampler().isImage()) {
              error(loc, "operator[] on a non-RW texture must be an r-value", "", "");
              return true;
          }
      }
  
      // We tolerate samplers as l-values, even though they are nominally
      // illegal, because we expect a later optimization to eliminate them.
      if (node->getType().getBasicType() == EbtSampler) {
          intermediate.setNeedsLegalization();
          return false;
      }
  
      // Let the base class check errors
      return TParseContextBase::lValueErrorCheck(loc, op, node);
  }
  
  //
  // This function handles l-value conversions and verifications.  It uses, but is not synonymous
  // with lValueErrorCheck.  That function accepts an l-value directly, while this one must be
  // given the surrounding tree - e.g, with an assignment, so we can convert the assign into a
  // series of other image operations.
  //
  // Most things are passed through unmodified, except for error checking.
  //
  TIntermTyped* HlslParseContext::handleLvalue(const TSourceLoc& loc, const char* op, TIntermTyped*& node)
  {
      if (node == nullptr)
          return nullptr;
  
      TIntermBinary* nodeAsBinary = node->getAsBinaryNode();
      TIntermUnary* nodeAsUnary = node->getAsUnaryNode();
      TIntermAggregate* sequence = nullptr;
  
      TIntermTyped* lhs = nodeAsUnary  ? nodeAsUnary->getOperand() :
                          nodeAsBinary ? nodeAsBinary->getLeft() :
                          nullptr;
  
      // Early bail out if there is no conversion to apply
      if (!shouldConvertLValue(lhs)) {
          if (lhs != nullptr)
              if (lValueErrorCheck(loc, op, lhs))
                  return nullptr;
          return node;
      }
  
      // *** If we get here, we're going to apply some conversion to an l-value.
  
      // Helper to create a load.
      const auto makeLoad = [&](TIntermSymbol* rhsTmp, TIntermTyped* object, TIntermTyped* coord, const TType& derefType) {
          TIntermAggregate* loadOp = new TIntermAggregate(EOpImageLoad);
          loadOp->setLoc(loc);
          loadOp->getSequence().push_back(object);
          loadOp->getSequence().push_back(intermediate.addSymbol(*coord->getAsSymbolNode()));
          loadOp->setType(derefType);
  
          sequence = intermediate.growAggregate(sequence,
                                                intermediate.addAssign(EOpAssign, rhsTmp, loadOp, loc),
                                                loc);
      };
  
      // Helper to create a store.
      const auto makeStore = [&](TIntermTyped* object, TIntermTyped* coord, TIntermSymbol* rhsTmp) {
          TIntermAggregate* storeOp = new TIntermAggregate(EOpImageStore);
          storeOp->getSequence().push_back(object);
          storeOp->getSequence().push_back(coord);
          storeOp->getSequence().push_back(intermediate.addSymbol(*rhsTmp));
          storeOp->setLoc(loc);
          storeOp->setType(TType(EbtVoid));
  
          sequence = intermediate.growAggregate(sequence, storeOp);
      };
  
      // Helper to create an assign.
      const auto makeBinary = [&](TOperator op, TIntermTyped* lhs, TIntermTyped* rhs) {
          sequence = intermediate.growAggregate(sequence,
                                                intermediate.addBinaryNode(op, lhs, rhs, loc, lhs->getType()),
                                                loc);
      };
  
      // Helper to complete sequence by adding trailing variable, so we evaluate to the right value.
      const auto finishSequence = [&](TIntermSymbol* rhsTmp, const TType& derefType) -> TIntermAggregate* {
          // Add a trailing use of the temp, so the sequence returns the proper value.
          sequence = intermediate.growAggregate(sequence, intermediate.addSymbol(*rhsTmp));
          sequence->setOperator(EOpSequence);
          sequence->setLoc(loc);
          sequence->setType(derefType);
  
          return sequence;
      };
  
      // Helper to add unary op
      const auto makeUnary = [&](TOperator op, TIntermSymbol* rhsTmp) {
          sequence = intermediate.growAggregate(sequence,
                                                intermediate.addUnaryNode(op, intermediate.addSymbol(*rhsTmp), loc,
                                                                          rhsTmp->getType()),
                                                loc);
      };
  
      // Return true if swizzle or index writes all components of the given variable.
      const auto writesAllComponents = [&](TIntermSymbol* var, TIntermBinary* swizzle) -> bool {
          if (swizzle == nullptr)  // not a swizzle or index
              return true;
  
          // Track which components are being set.
          std::array<bool, 4> compIsSet;
          compIsSet.fill(false);
  
          const TIntermConstantUnion* asConst     = swizzle->getRight()->getAsConstantUnion();
          const TIntermAggregate*     asAggregate = swizzle->getRight()->getAsAggregate();
  
          // This could be either a direct index, or a swizzle.
          if (asConst) {
              compIsSet[asConst->getConstArray()[0].getIConst()] = true;
          } else if (asAggregate) {
              const TIntermSequence& seq = asAggregate->getSequence();
              for (int comp=0; comp<int(seq.size()); ++comp)
                  compIsSet[seq[comp]->getAsConstantUnion()->getConstArray()[0].getIConst()] = true;
          } else {
              assert(0);
          }
  
          // Return true if all components are being set by the index or swizzle
          return std::all_of(compIsSet.begin(), compIsSet.begin() + var->getType().getVectorSize(),
                             [](bool isSet) { return isSet; } );
      };
  
      // Create swizzle matching input swizzle
      const auto addSwizzle = [&](TIntermSymbol* var, TIntermBinary* swizzle) -> TIntermTyped* {
          if (swizzle)
              return intermediate.addBinaryNode(swizzle->getOp(), var, swizzle->getRight(), loc, swizzle->getType());
          else
              return var;
      };
  
      TIntermBinary*    lhsAsBinary    = lhs->getAsBinaryNode();
      TIntermAggregate* lhsAsAggregate = lhs->getAsAggregate();
      bool lhsIsSwizzle = false;
  
      // If it's a swizzled L-value, remember the swizzle, and use the LHS.
      if (lhsAsBinary != nullptr && (lhsAsBinary->getOp() == EOpVectorSwizzle || lhsAsBinary->getOp() == EOpIndexDirect)) {
          lhsAsAggregate = lhsAsBinary->getLeft()->getAsAggregate();
          lhsIsSwizzle = true;
      }
  
      TIntermTyped* object = lhsAsAggregate->getSequence()[0]->getAsTyped();
      TIntermTyped* coord  = lhsAsAggregate->getSequence()[1]->getAsTyped();
  
      const TSampler& texSampler = object->getType().getSampler();
  
      TType objDerefType;
      getTextureReturnType(texSampler, objDerefType);
  
      if (nodeAsBinary) {
          TIntermTyped* rhs = nodeAsBinary->getRight();
          const TOperator assignOp = nodeAsBinary->getOp();
  
          bool isModifyOp = false;
  
          switch (assignOp) {
          case EOpAddAssign:
          case EOpSubAssign:
          case EOpMulAssign:
          case EOpVectorTimesMatrixAssign:
          case EOpVectorTimesScalarAssign:
          case EOpMatrixTimesScalarAssign:
          case EOpMatrixTimesMatrixAssign:
          case EOpDivAssign:
          case EOpModAssign:
          case EOpAndAssign:
          case EOpInclusiveOrAssign:
          case EOpExclusiveOrAssign:
          case EOpLeftShiftAssign:
          case EOpRightShiftAssign:
              isModifyOp = true;
              // fall through...
          case EOpAssign:
              {
                  // Since this is an lvalue, we'll convert an image load to a sequence like this
                  // (to still provide the value):
                  //   OpSequence
                  //      OpImageStore(object, lhs, rhs)
                  //      rhs
                  // But if it's not a simple symbol RHS (say, a fn call), we don't want to duplicate the RHS,
                  // so we'll convert instead to this:
                  //   OpSequence
                  //      rhsTmp = rhs
                  //      OpImageStore(object, coord, rhsTmp)
                  //      rhsTmp
                  // If this is a read-modify-write op, like +=, we issue:
                  //   OpSequence
                  //      coordtmp = load's param1
                  //      rhsTmp = OpImageLoad(object, coordTmp)
                  //      rhsTmp op= rhs
                  //      OpImageStore(object, coordTmp, rhsTmp)
                  //      rhsTmp
                  //
                  // If the lvalue is swizzled, we apply that when writing the temp variable, like so:
                  //    ...
                  //    rhsTmp.some_swizzle = ...
                  // For partial writes, an error is generated.
  
                  TIntermSymbol* rhsTmp = rhs->getAsSymbolNode();
                  TIntermTyped* coordTmp = coord;
  
                  if (rhsTmp == nullptr || isModifyOp || lhsIsSwizzle) {
                      rhsTmp = makeInternalVariableNode(loc, "storeTemp", objDerefType);
  
                      // Partial updates not yet supported
                      if (!writesAllComponents(rhsTmp, lhsAsBinary)) {
                          error(loc, "unimplemented: partial image updates", "", "");
                      }
  
                      // Assign storeTemp = rhs
                      if (isModifyOp) {
                          // We have to make a temp var for the coordinate, to avoid evaluating it twice.
                          coordTmp = makeInternalVariableNode(loc, "coordTemp", coord->getType());
                          makeBinary(EOpAssign, coordTmp, coord); // coordtmp = load[param1]
                          makeLoad(rhsTmp, object, coordTmp, objDerefType); // rhsTmp = OpImageLoad(object, coordTmp)
                      }
  
                      // rhsTmp op= rhs.
                      makeBinary(assignOp, addSwizzle(intermediate.addSymbol(*rhsTmp), lhsAsBinary), rhs);
                  }
  
                  makeStore(object, coordTmp, rhsTmp);         // add a store
                  return finishSequence(rhsTmp, objDerefType); // return rhsTmp from sequence
              }
  
          default:
              break;
          }
      }
  
      if (nodeAsUnary) {
          const TOperator assignOp = nodeAsUnary->getOp();
  
          switch (assignOp) {
          case EOpPreIncrement:
          case EOpPreDecrement:
              {
                  // We turn this into:
                  //   OpSequence
                  //      coordtmp = load's param1
                  //      rhsTmp = OpImageLoad(object, coordTmp)
                  //      rhsTmp op
                  //      OpImageStore(object, coordTmp, rhsTmp)
                  //      rhsTmp
  
                  TIntermSymbol* rhsTmp = makeInternalVariableNode(loc, "storeTemp", objDerefType);
                  TIntermTyped* coordTmp = makeInternalVariableNode(loc, "coordTemp", coord->getType());
  
                  makeBinary(EOpAssign, coordTmp, coord);           // coordtmp = load[param1]
                  makeLoad(rhsTmp, object, coordTmp, objDerefType); // rhsTmp = OpImageLoad(object, coordTmp)
                  makeUnary(assignOp, rhsTmp);                      // op rhsTmp
                  makeStore(object, coordTmp, rhsTmp);              // OpImageStore(object, coordTmp, rhsTmp)
                  return finishSequence(rhsTmp, objDerefType);      // return rhsTmp from sequence
              }
  
          case EOpPostIncrement:
          case EOpPostDecrement:
              {
                  // We turn this into:
                  //   OpSequence
                  //      coordtmp = load's param1
                  //      rhsTmp1 = OpImageLoad(object, coordTmp)
                  //      rhsTmp2 = rhsTmp1
                  //      rhsTmp2 op
                  //      OpImageStore(object, coordTmp, rhsTmp2)
                  //      rhsTmp1 (pre-op value)
                  TIntermSymbol* rhsTmp1 = makeInternalVariableNode(loc, "storeTempPre",  objDerefType);
                  TIntermSymbol* rhsTmp2 = makeInternalVariableNode(loc, "storeTempPost", objDerefType);
                  TIntermTyped* coordTmp = makeInternalVariableNode(loc, "coordTemp", coord->getType());
  
                  makeBinary(EOpAssign, coordTmp, coord);            // coordtmp = load[param1]
                  makeLoad(rhsTmp1, object, coordTmp, objDerefType); // rhsTmp1 = OpImageLoad(object, coordTmp)
                  makeBinary(EOpAssign, rhsTmp2, rhsTmp1);           // rhsTmp2 = rhsTmp1
                  makeUnary(assignOp, rhsTmp2);                      // rhsTmp op
                  makeStore(object, coordTmp, rhsTmp2);              // OpImageStore(object, coordTmp, rhsTmp2)
                  return finishSequence(rhsTmp1, objDerefType);      // return rhsTmp from sequence
              }
  
          default:
              break;
          }
      }
  
      if (lhs)
          if (lValueErrorCheck(loc, op, lhs))
              return nullptr;
  
      return node;
  }
  
  void HlslParseContext::handlePragma(const TSourceLoc& loc, const TVector<TString>& tokens)
  {
      if (pragmaCallback)
          pragmaCallback(loc.line, tokens);
  
      if (tokens.size() == 0)
          return;
  
      // These pragmas are case insensitive in HLSL, so we'll compare in lower case.
      TVector<TString> lowerTokens = tokens;
  
      for (auto it = lowerTokens.begin(); it != lowerTokens.end(); ++it)
          std::transform(it->begin(), it->end(), it->begin(), ::tolower);
  
      // Handle pack_matrix
      if (tokens.size() == 4 && lowerTokens[0] == "pack_matrix" && tokens[1] == "(" && tokens[3] == ")") {
          // Note that HLSL semantic order is Mrc, not Mcr like SPIR-V, so we reverse the sense.
          // Row major becomes column major and vice versa.
  
          if (lowerTokens[2] == "row_major") {
              globalUniformDefaults.layoutMatrix = globalBufferDefaults.layoutMatrix = ElmColumnMajor;
          } else if (lowerTokens[2] == "column_major") {
              globalUniformDefaults.layoutMatrix = globalBufferDefaults.layoutMatrix = ElmRowMajor;
          } else {
              // unknown majorness strings are treated as (HLSL column major)==(SPIR-V row major)
              warn(loc, "unknown pack_matrix pragma value", tokens[2].c_str(), "");
              globalUniformDefaults.layoutMatrix = globalBufferDefaults.layoutMatrix = ElmRowMajor;
          }
          return;
      }
  
      // Handle once
      if (lowerTokens[0] == "once") {
          warn(loc, "not implemented", "#pragma once", "");
          return;
      }
  }
  
  //
  // Look at a '.' matrix selector string and change it into components
  // for a matrix. There are two types:
  //
  //   _21    second row, first column (one based)
  //   _m21   third row, second column (zero based)
  //
  // Returns true if there is no error.
  //
  bool HlslParseContext::parseMatrixSwizzleSelector(const TSourceLoc& loc, const TString& fields, int cols, int rows,
                                                    TSwizzleSelectors<TMatrixSelector>& components)
  {
      int startPos[MaxSwizzleSelectors];
      int numComps = 0;
      TString compString = fields;
  
      // Find where each component starts,
      // recording the first character position after the '_'.
      for (size_t c = 0; c < compString.size(); ++c) {
          if (compString[c] == '_') {
              if (numComps >= MaxSwizzleSelectors) {
                  error(loc, "matrix component swizzle has too many components", compString.c_str(), "");
                  return false;
              }
              if (c > compString.size() - 3 ||
                      ((compString[c+1] == 'm' || compString[c+1] == 'M') && c > compString.size() - 4)) {
                  error(loc, "matrix component swizzle missing", compString.c_str(), "");
                  return false;
              }
              startPos[numComps++] = (int)c + 1;
          }
      }
  
      // Process each component
      for (int i = 0; i < numComps; ++i) {
          int pos = startPos[i];
          int bias = -1;
          if (compString[pos] == 'm' || compString[pos] == 'M') {
              bias = 0;
              ++pos;
          }
          TMatrixSelector comp;
          comp.coord1 = compString[pos+0] - '0' + bias;
          comp.coord2 = compString[pos+1] - '0' + bias;
          if (comp.coord1 < 0 || comp.coord1 >= cols) {
              error(loc, "matrix row component out of range", compString.c_str(), "");
              return false;
          }
          if (comp.coord2 < 0 || comp.coord2 >= rows) {
              error(loc, "matrix column component out of range", compString.c_str(), "");
              return false;
          }
          components.push_back(comp);
      }
  
      return true;
  }
  
  // If the 'comps' express a column of a matrix,
  // return the column.  Column means the first coords all match.
  //
  // Otherwise, return -1.
  //
  int HlslParseContext::getMatrixComponentsColumn(int rows, const TSwizzleSelectors<TMatrixSelector>& selector)
  {
      int col = -1;
  
      // right number of comps?
      if (selector.size() != rows)
          return -1;
  
      // all comps in the same column?
      // rows in order?
      col = selector[0].coord1;
      for (int i = 0; i < rows; ++i) {
          if (col != selector[i].coord1)
              return -1;
          if (i != selector[i].coord2)
              return -1;
      }
  
      return col;
  }
  
  //
  // Handle seeing a variable identifier in the grammar.
  //
  TIntermTyped* HlslParseContext::handleVariable(const TSourceLoc& loc, const TString* string)
  {
      int thisDepth;
      TSymbol* symbol = symbolTable.find(*string, thisDepth);
      if (symbol && symbol->getAsVariable() && symbol->getAsVariable()->isUserType()) {
          error(loc, "expected symbol, not user-defined type", string->c_str(), "");
          return nullptr;
      }
  
      const TVariable* variable = nullptr;
      const TAnonMember* anon = symbol ? symbol->getAsAnonMember() : nullptr;
      TIntermTyped* node = nullptr;
      if (anon) {
          // It was a member of an anonymous container, which could be a 'this' structure.
  
          // Create a subtree for its dereference.
          if (thisDepth > 0) {
              variable = getImplicitThis(thisDepth);
              if (variable == nullptr)
                  error(loc, "cannot access member variables (static member function?)", "this", "");
          }
          if (variable == nullptr)
              variable = anon->getAnonContainer().getAsVariable();
  
          TIntermTyped* container = intermediate.addSymbol(*variable, loc);
          TIntermTyped* constNode = intermediate.addConstantUnion(anon->getMemberNumber(), loc);
          node = intermediate.addIndex(EOpIndexDirectStruct, container, constNode, loc);
  
          node->setType(*(*variable->getType().getStruct())[anon->getMemberNumber()].type);
          if (node->getType().hiddenMember())
              error(loc, "member of nameless block was not redeclared", string->c_str(), "");
      } else {
          // Not a member of an anonymous container.
  
          // The symbol table search was done in the lexical phase.
          // See if it was a variable.
          variable = symbol ? symbol->getAsVariable() : nullptr;
          if (variable) {
              if ((variable->getType().getBasicType() == EbtBlock ||
                  variable->getType().getBasicType() == EbtStruct) && variable->getType().getStruct() == nullptr) {
                  error(loc, "cannot be used (maybe an instance name is needed)", string->c_str(), "");
                  variable = nullptr;
              }
          } else {
              if (symbol)
                  error(loc, "variable name expected", string->c_str(), "");
          }
  
          // Recovery, if it wasn't found or was not a variable.
          if (variable == nullptr) {
              error(loc, "unknown variable", string->c_str(), "");
              variable = new TVariable(string, TType(EbtVoid));
          }
  
          if (variable->getType().getQualifier().isFrontEndConstant())
              node = intermediate.addConstantUnion(variable->getConstArray(), variable->getType(), loc);
          else
              node = intermediate.addSymbol(*variable, loc);
      }
  
      if (variable->getType().getQualifier().isIo())
          intermediate.addIoAccessed(*string);
  
      return node;
  }
  
  //
  // Handle operator[] on any objects it applies to.  Currently:
  //    Textures
  //    Buffers
  //
  TIntermTyped* HlslParseContext::handleBracketOperator(const TSourceLoc& loc, TIntermTyped* base, TIntermTyped* index)
  {
      // handle r-value operator[] on textures and images.  l-values will be processed later.
      if (base->getType().getBasicType() == EbtSampler && !base->isArray()) {
          const TSampler& sampler = base->getType().getSampler();
          if (sampler.isImage() || sampler.isTexture()) {
              if (! mipsOperatorMipArg.empty() && mipsOperatorMipArg.back().mipLevel == nullptr) {
                  // The first operator[] to a .mips[] sequence is the mip level.  We'll remember it.
                  mipsOperatorMipArg.back().mipLevel = index;
                  return base;  // next [] index is to the same base.
              } else {
                  TIntermAggregate* load = new TIntermAggregate(sampler.isImage() ? EOpImageLoad : EOpTextureFetch);
  
                  TType sampReturnType;
                  getTextureReturnType(sampler, sampReturnType);
  
                  load->setType(sampReturnType);
                  load->setLoc(loc);
                  load->getSequence().push_back(base);
                  load->getSequence().push_back(index);
  
                  // Textures need a MIP.  If we saw one go by, use it.  Otherwise, use zero.
                  if (sampler.isTexture()) {
                      if (! mipsOperatorMipArg.empty()) {
                          load->getSequence().push_back(mipsOperatorMipArg.back().mipLevel);
                          mipsOperatorMipArg.pop_back();
                      } else {
                          load->getSequence().push_back(intermediate.addConstantUnion(0, loc, true));
                      }
                  }
  
                  return load;
              }
          }
      }
  
      // Handle operator[] on structured buffers: this indexes into the array element of the buffer.
      // indexStructBufferContent returns nullptr if it isn't a structuredbuffer (SSBO).
      TIntermTyped* sbArray = indexStructBufferContent(loc, base);
      if (sbArray != nullptr) {
          // Now we'll apply the [] index to that array
          const TOperator idxOp = (index->getQualifier().storage == EvqConst) ? EOpIndexDirect : EOpIndexIndirect;
  
          TIntermTyped* element = intermediate.addIndex(idxOp, sbArray, index, loc);
          const TType derefType(sbArray->getType(), 0);
          element->setType(derefType);
          return element;
      }
  
      return nullptr;
  }
  
  //
  // Cast index value to a uint if it isn't already (for operator[], load indexes, etc)
  TIntermTyped* HlslParseContext::makeIntegerIndex(TIntermTyped* index)
  {
      const TBasicType indexBasicType = index->getType().getBasicType();
      const int vecSize = index->getType().getVectorSize();
  
      // We can use int types directly as the index
      if (indexBasicType == EbtInt || indexBasicType == EbtUint ||
          indexBasicType == EbtInt64 || indexBasicType == EbtUint64)
          return index;
  
      // Cast index to unsigned integer if it isn't one.
      return intermediate.addConversion(EOpConstructUint, TType(EbtUint, EvqTemporary, vecSize), index);
  }
  
  //
  // Handle seeing a base[index] dereference in the grammar.
  //
  TIntermTyped* HlslParseContext::handleBracketDereference(const TSourceLoc& loc, TIntermTyped* base, TIntermTyped* index)
  {
      index = makeIntegerIndex(index);
  
      if (index == nullptr) {
          error(loc, " unknown index type ", "", "");
          return nullptr;
      }
  
      TIntermTyped* result = handleBracketOperator(loc, base, index);
  
      if (result != nullptr)
          return result;  // it was handled as an operator[]
  
      bool flattened = false;
      int indexValue = 0;
      if (index->getQualifier().isFrontEndConstant())
          indexValue = index->getAsConstantUnion()->getConstArray()[0].getIConst();
  
      variableCheck(base);
      if (! base->isArray() && ! base->isMatrix() && ! base->isVector()) {
          if (base->getAsSymbolNode())
              error(loc, " left of '[' is not of type array, matrix, or vector ",
                    base->getAsSymbolNode()->getName().c_str(), "");
          else
              error(loc, " left of '[' is not of type array, matrix, or vector ", "expression", "");
      } else if (base->getType().getQualifier().isFrontEndConstant() && 
                 index->getQualifier().isFrontEndConstant()) {
          // both base and index are front-end constants
          checkIndex(loc, base->getType(), indexValue);
          return intermediate.foldDereference(base, indexValue, loc);
      } else {
          // at least one of base and index is variable...
  
          if (index->getQualifier().isFrontEndConstant())
              checkIndex(loc, base->getType(), indexValue);
  
          if (base->getType().isScalarOrVec1())
              result = base;
          else if (base->getAsSymbolNode() && wasFlattened(base)) {
              if (index->getQualifier().storage != EvqConst)
                  error(loc, "Invalid variable index to flattened array", base->getAsSymbolNode()->getName().c_str(), "");
  
              result = flattenAccess(base, indexValue);
              flattened = (result != base);
          } else {
              if (index->getQualifier().isFrontEndConstant()) {
                  if (base->getType().isUnsizedArray())
                      base->getWritableType().updateImplicitArraySize(indexValue + 1);
                  else
                      checkIndex(loc, base->getType(), indexValue);
                  result = intermediate.addIndex(EOpIndexDirect, base, index, loc);
              } else
                  result = intermediate.addIndex(EOpIndexIndirect, base, index, loc);
          }
      }
  
      if (result == nullptr) {
          // Insert dummy error-recovery result
          result = intermediate.addConstantUnion(0.0, EbtFloat, loc);
      } else {
          // If the array reference was flattened, it has the correct type.  E.g, if it was
          // a uniform array, it was flattened INTO a set of scalar uniforms, not scalar temps.
          // In that case, we preserve the qualifiers.
          if (!flattened) {
              // Insert valid dereferenced result
              TType newType(base->getType(), 0);  // dereferenced type
              if (base->getType().getQualifier().storage == EvqConst && index->getQualifier().storage == EvqConst)
                  newType.getQualifier().storage = EvqConst;
              else
                  newType.getQualifier().storage = EvqTemporary;
              result->setType(newType);
          }
      }
  
      return result;
  }
  
  // Handle seeing a binary node with a math operation.
  TIntermTyped* HlslParseContext::handleBinaryMath(const TSourceLoc& loc, const char* str, TOperator op,
                                                   TIntermTyped* left, TIntermTyped* right)
  {
      TIntermTyped* result = intermediate.addBinaryMath(op, left, right, loc);
      if (result == nullptr)
          binaryOpError(loc, str, left->getCompleteString(), right->getCompleteString());
  
      return result;
  }
  
  // Handle seeing a unary node with a math operation.
  TIntermTyped* HlslParseContext::handleUnaryMath(const TSourceLoc& loc, const char* str, TOperator op,
                                                  TIntermTyped* childNode)
  {
      TIntermTyped* result = intermediate.addUnaryMath(op, childNode, loc);
  
      if (result)
          return result;
      else
          unaryOpError(loc, str, childNode->getCompleteString());
  
      return childNode;
  }
  //
  // Return true if the name is a struct buffer method
  //
  bool HlslParseContext::isStructBufferMethod(const TString& name) const
  {
      return
          name == "GetDimensions"              ||
          name == "Load"                       ||
          name == "Load2"                      ||
          name == "Load3"                      ||
          name == "Load4"                      ||
          name == "Store"                      ||
          name == "Store2"                     ||
          name == "Store3"                     ||
          name == "Store4"                     ||
          name == "InterlockedAdd"             ||
          name == "InterlockedAnd"             ||
          name == "InterlockedCompareExchange" ||
          name == "InterlockedCompareStore"    ||
          name == "InterlockedExchange"        ||
          name == "InterlockedMax"             ||
          name == "InterlockedMin"             ||
          name == "InterlockedOr"              ||
          name == "InterlockedXor"             ||
          name == "IncrementCounter"           ||
          name == "DecrementCounter"           ||
          name == "Append"                     ||
          name == "Consume";
  }
  
  //
  // Handle seeing a base.field dereference in the grammar, where 'field' is a
  // swizzle or member variable.
  //
  TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TIntermTyped* base, const TString& field)
  {
      variableCheck(base);
  
      if (base->isArray()) {
          error(loc, "cannot apply to an array:", ".", field.c_str());
          return base;
      }
  
      TIntermTyped* result = base;
  
      if (base->getType().getBasicType() == EbtSampler) {
          // Handle .mips[mipid][pos] operation on textures
          const TSampler& sampler = base->getType().getSampler();
          if (sampler.isTexture() && field == "mips") {
              // Push a null to signify that we expect a mip level under operator[] next.
              mipsOperatorMipArg.push_back(tMipsOperatorData(loc, nullptr));
              // Keep 'result' pointing to 'base', since we expect an operator[] to go by next.
          } else {
              if (field == "mips")
                  error(loc, "unexpected texture type for .mips[][] operator:",
                        base->getType().getCompleteString().c_str(), "");
              else
                  error(loc, "unexpected operator on texture type:", field.c_str(),
                        base->getType().getCompleteString().c_str());
          }
      } else if (base->isVector() || base->isScalar()) {
          TSwizzleSelectors<TVectorSelector> selectors;
          parseSwizzleSelector(loc, field, base->getVectorSize(), selectors);
  
          if (base->isScalar()) {
              if (selectors.size() == 1)
                  return result;
              else {
                  TType type(base->getBasicType(), EvqTemporary, selectors.size());
                  return addConstructor(loc, base, type);
              }
          }
          if (base->getVectorSize() == 1) {
              TType scalarType(base->getBasicType(), EvqTemporary, 1);
              if (selectors.size() == 1)
                  return addConstructor(loc, base, scalarType);
              else {
                  TType vectorType(base->getBasicType(), EvqTemporary, selectors.size());
                  return addConstructor(loc, addConstructor(loc, base, scalarType), vectorType);
              }
          }
  
          if (base->getType().getQualifier().isFrontEndConstant())
              result = intermediate.foldSwizzle(base, selectors, loc);
          else {
              if (selectors.size() == 1) {
                  TIntermTyped* index = intermediate.addConstantUnion(selectors[0], loc);
                  result = intermediate.addIndex(EOpIndexDirect, base, index, loc);
                  result->setType(TType(base->getBasicType(), EvqTemporary));
              } else {
                  TIntermTyped* index = intermediate.addSwizzle(selectors, loc);
                  result = intermediate.addIndex(EOpVectorSwizzle, base, index, loc);
                  result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision,
                                  selectors.size()));
              }
          }
      } else if (base->isMatrix()) {
          TSwizzleSelectors<TMatrixSelector> selectors;
          if (! parseMatrixSwizzleSelector(loc, field, base->getMatrixCols(), base->getMatrixRows(), selectors))
              return result;
  
          if (selectors.size() == 1) {
              // Representable by m[c][r]
              if (base->getType().getQualifier().isFrontEndConstant()) {
                  result = intermediate.foldDereference(base, selectors[0].coord1, loc);
                  result = intermediate.foldDereference(result, selectors[0].coord2, loc);
              } else {
                  result = intermediate.addIndex(EOpIndexDirect, base,
                                                 intermediate.addConstantUnion(selectors[0].coord1, loc),
                                                 loc);
                  TType dereferencedCol(base->getType(), 0);
                  result->setType(dereferencedCol);
                  result = intermediate.addIndex(EOpIndexDirect, result,
                                                 intermediate.addConstantUnion(selectors[0].coord2, loc),
                                                 loc);
                  TType dereferenced(dereferencedCol, 0);
                  result->setType(dereferenced);
              }
          } else {
              int column = getMatrixComponentsColumn(base->getMatrixRows(), selectors);
              if (column >= 0) {
                  // Representable by m[c]
                  if (base->getType().getQualifier().isFrontEndConstant())
                      result = intermediate.foldDereference(base, column, loc);
                  else {
                      result = intermediate.addIndex(EOpIndexDirect, base, intermediate.addConstantUnion(column, loc),
                                                     loc);
                      TType dereferenced(base->getType(), 0);
                      result->setType(dereferenced);
                  }
              } else {
                  // general case, not a column, not a single component
                  TIntermTyped* index = intermediate.addSwizzle(selectors, loc);
                  result = intermediate.addIndex(EOpMatrixSwizzle, base, index, loc);
                  result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision,
                                        selectors.size()));
             }
          }
      } else if (base->getBasicType() == EbtStruct || base->getBasicType() == EbtBlock) {
          const TTypeList* fields = base->getType().getStruct();
          bool fieldFound = false;
          int member;
          for (member = 0; member < (int)fields->size(); ++member) {
              if ((*fields)[member].type->getFieldName() == field) {
                  fieldFound = true;
                  break;
              }
          }
          if (fieldFound) {
              if (base->getAsSymbolNode() && wasFlattened(base)) {
                  result = flattenAccess(base, member);
              } else {
                  if (base->getType().getQualifier().storage == EvqConst)
                      result = intermediate.foldDereference(base, member, loc);
                  else {
                      TIntermTyped* index = intermediate.addConstantUnion(member, loc);
                      result = intermediate.addIndex(EOpIndexDirectStruct, base, index, loc);
                      result->setType(*(*fields)[member].type);
                  }
              }
          } else
              error(loc, "no such field in structure", field.c_str(), "");
      } else
          error(loc, "does not apply to this type:", field.c_str(), base->getType().getCompleteString().c_str());
  
      return result;
  }
  
  //
  // Return true if the field should be treated as a built-in method.
  // Return false otherwise.
  //
  bool HlslParseContext::isBuiltInMethod(const TSourceLoc&, TIntermTyped* base, const TString& field)
  {
      if (base == nullptr)
          return false;
  
      variableCheck(base);
  
      if (base->getType().getBasicType() == EbtSampler) {
          return true;
      } else if (isStructBufferType(base->getType()) && isStructBufferMethod(field)) {
          return true;
      } else if (field == "Append" ||
                 field == "RestartStrip") {
          // We cannot check the type here: it may be sanitized if we're not compiling a geometry shader, but
          // the code is around in the shader source.
          return true;
      } else
          return false;
  }
  
  // Independently establish a built-in that is a member of a structure.
  // 'arraySizes' are what's desired for the independent built-in, whatever
  // the higher-level source/expression of them was.
  void HlslParseContext::splitBuiltIn(const TString& baseName, const TType& memberType, const TArraySizes* arraySizes,
                                      const TQualifier& outerQualifier)
  {
      // Because of arrays of structs, we might be asked more than once,
      // but the arraySizes passed in should have captured the whole thing
      // the first time.
      // However, clip/cull rely on multiple updates.
      if (!isClipOrCullDistance(memberType))
          if (splitBuiltIns.find(tInterstageIoData(memberType.getQualifier().builtIn, outerQualifier.storage)) !=
              splitBuiltIns.end())
              return;
  
      TVariable* ioVar = makeInternalVariable(baseName + "." + memberType.getFieldName(), memberType);
  
      if (arraySizes != nullptr && !memberType.isArray())
          ioVar->getWritableType().copyArraySizes(*arraySizes);
  
      splitBuiltIns[tInterstageIoData(memberType.getQualifier().builtIn, outerQualifier.storage)] = ioVar;
      if (!isClipOrCullDistance(ioVar->getType()))
          trackLinkage(*ioVar);
  
      // Merge qualifier from the user structure
      mergeQualifiers(ioVar->getWritableType().getQualifier(), outerQualifier);
  
      // Fix the builtin type if needed (e.g, some types require fixed array sizes, no matter how the
      // shader declared them).  This is done after mergeQualifiers(), in case fixBuiltInIoType looks
      // at the qualifier to determine e.g, in or out qualifications.
      fixBuiltInIoType(ioVar->getWritableType());
  
      // But, not location, we're losing that
      ioVar->getWritableType().getQualifier().layoutLocation = TQualifier::layoutLocationEnd;
  }
  
  // Split a type into
  //   1. a struct of non-I/O members
  //   2. a collection of independent I/O variables
  void HlslParseContext::split(const TVariable& variable)
  {
      // Create a new variable:
      const TType& clonedType = *variable.getType().clone();
      const TType& splitType = split(clonedType, variable.getName(), clonedType.getQualifier());
      splitNonIoVars[variable.getUniqueId()] = makeInternalVariable(variable.getName(), splitType);
  }
  
  // Recursive implementation of split().
  // Returns reference to the modified type.
  const TType& HlslParseContext::split(const TType& type, const TString& name, const TQualifier& outerQualifier)
  {
      if (type.isStruct()) {
          TTypeList* userStructure = type.getWritableStruct();
          for (auto ioType = userStructure->begin(); ioType != userStructure->end(); ) {
              if (ioType->type->isBuiltIn()) {
                  // move out the built-in
                  splitBuiltIn(name, *ioType->type, type.getArraySizes(), outerQualifier);
                  ioType = userStructure->erase(ioType);
              } else {
                  split(*ioType->type, name + "." + ioType->type->getFieldName(), outerQualifier);
                  ++ioType;
              }
          }
      }
  
      return type;
  }
  
  // Is this an aggregate that should be flattened?
  // Can be applied to intermediate levels of type in a hierarchy.
  // Some things like flattening uniform arrays are only about the top level
  // of the aggregate, triggered on 'topLevel'.
  bool HlslParseContext::shouldFlatten(const TType& type, TStorageQualifier qualifier, bool topLevel) const
  {
      switch (qualifier) {
      case EvqVaryingIn:
      case EvqVaryingOut:
          return type.isStruct() || type.isArray();
      case EvqUniform:
          return (type.isArray() && intermediate.getFlattenUniformArrays() && topLevel) ||
                 (type.isStruct() && type.containsOpaque());
      default:
          return false;
      };
  }
  
  // Top level variable flattening: construct data
  void HlslParseContext::flatten(const TVariable& variable, bool linkage)
  {
      const TType& type = variable.getType();
  
      // If it's a standalone built-in, there is nothing to flatten
      if (type.isBuiltIn() && !type.isStruct())
          return;
  
      auto entry = flattenMap.insert(std::make_pair(variable.getUniqueId(),
                                                    TFlattenData(type.getQualifier().layoutBinding,
                                                                 type.getQualifier().layoutLocation)));
  
      // the item is a map pair, so first->second is the TFlattenData itself.
      flatten(variable, type, entry.first->second, variable.getName(), linkage, type.getQualifier(), nullptr);
  }
  
  // Recursively flatten the given variable at the provided type, building the flattenData as we go.
  //
  // This is mutually recursive with flattenStruct and flattenArray.
  // We are going to flatten an arbitrarily nested composite structure into a linear sequence of
  // members, and later on, we want to turn a path through the tree structure into a final
  // location in this linear sequence.
  //
  // If the tree was N-ary, that can be directly calculated.  However, we are dealing with
  // arbitrary numbers - perhaps a struct of 7 members containing an array of 3.  Thus, we must
  // build a data structure to allow the sequence of bracket and dot operators on arrays and
  // structs to arrive at the proper member.
  //
  // To avoid storing a tree with pointers, we are going to flatten the tree into a vector of integers.
  // The leaves are the indexes into the flattened member array.
  // Each level will have the next location for the Nth item stored sequentially, so for instance:
  //
  // struct { float2 a[2]; int b; float4 c[3] };
  //
  // This will produce the following flattened tree:
  // Pos: 0  1   2    3  4    5  6   7     8   9  10   11  12 13
  //     (3, 7,  8,   5, 6,   0, 1,  2,   11, 12, 13,   3,  4, 5}
  //
  // Given a reference to mystruct.c[1], the access chain is (2,1), so we traverse:
  //   (0+2) = 8  -->  (8+1) = 12 -->   12 = 4
  //
  // so the 4th flattened member in traversal order is ours.
  //
  int HlslParseContext::flatten(const TVariable& variable, const TType& type,
                                TFlattenData& flattenData, TString name, bool linkage,
                                const TQualifier& outerQualifier,
                                const TArraySizes* builtInArraySizes)
  {
      // If something is an arrayed struct, the array flattener will recursively call flatten()
      // to then flatten the struct, so this is an "if else": we don't do both.
      if (type.isArray())
          return flattenArray(variable, type, flattenData, name, linkage, outerQualifier);
      else if (type.isStruct())
          return flattenStruct(variable, type, flattenData, name, linkage, outerQualifier, builtInArraySizes);
      else {
          assert(0); // should never happen
          return -1;
      }
  }
  
  // Add a single flattened member to the flattened data being tracked for the composite
  // Returns true for the final flattening level.
  int HlslParseContext::addFlattenedMember(const TVariable& variable, const TType& type, TFlattenData& flattenData,
                                           const TString& memberName, bool linkage,
                                           const TQualifier& outerQualifier,
                                           const TArraySizes* builtInArraySizes)
  {
      if (!shouldFlatten(type, outerQualifier.storage, false)) {
          // This is as far as we flatten.  Insert the variable.
          TVariable* memberVariable = makeInternalVariable(memberName, type);
          mergeQualifiers(memberVariable->getWritableType().getQualifier(), variable.getType().getQualifier());
  
          if (flattenData.nextBinding != TQualifier::layoutBindingEnd)
              memberVariable->getWritableType().getQualifier().layoutBinding = flattenData.nextBinding++;
  
          if (memberVariable->getType().isBuiltIn()) {
              // inherited locations are nonsensical for built-ins (TODO: what if semantic had a number)
              memberVariable->getWritableType().getQualifier().layoutLocation = TQualifier::layoutLocationEnd;
          } else {
              // inherited locations must be auto bumped, not replicated
              if (flattenData.nextLocation != TQualifier::layoutLocationEnd) {
                  memberVariable->getWritableType().getQualifier().layoutLocation = flattenData.nextLocation;
                  flattenData.nextLocation += intermediate.computeTypeLocationSize(memberVariable->getType(), language);
                  nextOutLocation = std::max(nextOutLocation, flattenData.nextLocation);
              }
          }
  
          flattenData.offsets.push_back(static_cast<int>(flattenData.members.size()));
          flattenData.members.push_back(memberVariable);
  
          if (linkage)
              trackLinkage(*memberVariable);
  
          return static_cast<int>(flattenData.offsets.size()) - 1; // location of the member reference
      } else {
          // Further recursion required
          return flatten(variable, type, flattenData, memberName, linkage, outerQualifier, builtInArraySizes);
      }
  }
  
  // Figure out the mapping between an aggregate's top members and an
  // equivalent set of individual variables.
  //
  // Assumes shouldFlatten() or equivalent was called first.
  int HlslParseContext::flattenStruct(const TVariable& variable, const TType& type,
                                      TFlattenData& flattenData, TString name, bool linkage,
                                      const TQualifier& outerQualifier,
                                      const TArraySizes* builtInArraySizes)
  {
      assert(type.isStruct());
  
      auto members = *type.getStruct();
  
      // Reserve space for this tree level.
      int start = static_cast<int>(flattenData.offsets.size());
      int pos = start;
      flattenData.offsets.resize(int(pos + members.size()), -1);
  
      for (int member = 0; member < (int)members.size(); ++member) {
          TType& dereferencedType = *members[member].type;
          if (dereferencedType.isBuiltIn())
              splitBuiltIn(variable.getName(), dereferencedType, builtInArraySizes, outerQualifier);
          else {
              const int mpos = addFlattenedMember(variable, dereferencedType, flattenData,
                                                  name + "." + dereferencedType.getFieldName(),
                                                  linkage, outerQualifier,
                                                  builtInArraySizes == nullptr && dereferencedType.isArray()
                                                                         ? dereferencedType.getArraySizes()
                                                                         : builtInArraySizes);
              flattenData.offsets[pos++] = mpos;
          }
      }
  
      return start;
  }
  
  // Figure out mapping between an array's members and an
  // equivalent set of individual variables.
  //
  // Assumes shouldFlatten() or equivalent was called first.
  int HlslParseContext::flattenArray(const TVariable& variable, const TType& type,
                                     TFlattenData& flattenData, TString name, bool linkage,
                                     const TQualifier& outerQualifier)
  {
      assert(type.isSizedArray());
  
      const int size = type.getOuterArraySize();
      const TType dereferencedType(type, 0);
  
      if (name.empty())
          name = variable.getName();
  
      // Reserve space for this tree level.
      int start = static_cast<int>(flattenData.offsets.size());
      int pos   = start;
      flattenData.offsets.resize(int(pos + size), -1);
  
      for (int element=0; element < size; ++element) {
          char elementNumBuf[20];  // sufficient for MAXINT
          snprintf(elementNumBuf, sizeof(elementNumBuf)-1, "[%d]", element);
          const int mpos = addFlattenedMember(variable, dereferencedType, flattenData,
                                              name + elementNumBuf, linkage, outerQualifier,
                                              type.getArraySizes());
  
          flattenData.offsets[pos++] = mpos;
      }
  
      return start;
  }
  
  // Return true if we have flattened this node.
  bool HlslParseContext::wasFlattened(const TIntermTyped* node) const
  {
      return node != nullptr && node->getAsSymbolNode() != nullptr &&
             wasFlattened(node->getAsSymbolNode()->getId());
  }
  
  // Return true if we have split this structure
  bool HlslParseContext::wasSplit(const TIntermTyped* node) const
  {
      return node != nullptr && node->getAsSymbolNode() != nullptr &&
             wasSplit(node->getAsSymbolNode()->getId());
  }
  
  // Turn an access into an aggregate that was flattened to instead be
  // an access to the individual variable the member was flattened to.
  // Assumes wasFlattened() or equivalent was called first.
  TIntermTyped* HlslParseContext::flattenAccess(TIntermTyped* base, int member)
  {
      const TType dereferencedType(base->getType(), member);  // dereferenced type
      const TIntermSymbol& symbolNode = *base->getAsSymbolNode();
      TIntermTyped* flattened = flattenAccess(symbolNode.getId(), member, base->getQualifier().storage,
                                              dereferencedType, symbolNode.getFlattenSubset());
  
      return flattened ? flattened : base;
  }
  TIntermTyped* HlslParseContext::flattenAccess(int uniqueId, int member, TStorageQualifier outerStorage,
      const TType& dereferencedType, int subset)
  {
      const auto flattenData = flattenMap.find(uniqueId);
  
      if (flattenData == flattenMap.end())
          return nullptr;
  
      // Calculate new cumulative offset from the packed tree
      int newSubset = flattenData->second.offsets[subset >= 0 ? subset + member : member];
  
      TIntermSymbol* subsetSymbol;
      if (!shouldFlatten(dereferencedType, outerStorage, false)) {
          // Finished flattening: create symbol for variable
          member = flattenData->second.offsets[newSubset];
          const TVariable* memberVariable = flattenData->second.members[member];
          subsetSymbol = intermediate.addSymbol(*memberVariable);
          subsetSymbol->setFlattenSubset(-1);
      } else {
  
          // If this is not the final flattening, accumulate the position and return
          // an object of the partially dereferenced type.
          subsetSymbol = new TIntermSymbol(uniqueId, "flattenShadow", dereferencedType);
          subsetSymbol->setFlattenSubset(newSubset);
      }
  
      return subsetSymbol;
  }
  
  // For finding where the first leaf is in a subtree of a multi-level aggregate
  // that is just getting a subset assigned. Follows the same logic as flattenAccess,
  // but logically going down the "left-most" tree branch each step of the way.
  //
  // Returns the offset into the first leaf of the subset.
  int HlslParseContext::findSubtreeOffset(const TIntermNode& node) const
  {
      const TIntermSymbol* sym = node.getAsSymbolNode();
      if (sym == nullptr)
          return 0;
      if (!sym->isArray() && !sym->isStruct())
          return 0;
      int subset = sym->getFlattenSubset();
      if (subset == -1)
          return 0;
  
      // Getting this far means a partial aggregate is identified by the flatten subset.
      // Find the first leaf of the subset.
  
      const auto flattenData = flattenMap.find(sym->getId());
      if (flattenData == flattenMap.end())
          return 0;
  
      return findSubtreeOffset(sym->getType(), subset, flattenData->second.offsets);
  
      do {
          subset = flattenData->second.offsets[subset];
      } while (true);
  }
  // Recursively do the desent
  int HlslParseContext::findSubtreeOffset(const TType& type, int subset, const TVector<int>& offsets) const
  {
      if (!type.isArray() && !type.isStruct())
          return offsets[subset];
      TType derefType(type, 0);
      return findSubtreeOffset(derefType, offsets[subset], offsets);
  };
  
  // Find and return the split IO TVariable for id, or nullptr if none.
  TVariable* HlslParseContext::getSplitNonIoVar(int id) const
  {
      const auto splitNonIoVar = splitNonIoVars.find(id);
      if (splitNonIoVar == splitNonIoVars.end())
          return nullptr;
  
      return splitNonIoVar->second;
  }
  
  // Pass through to base class after remembering built-in mappings.
  void HlslParseContext::trackLinkage(TSymbol& symbol)
  {
      TBuiltInVariable biType = symbol.getType().getQualifier().builtIn;
  
      if (biType != EbvNone)
          builtInTessLinkageSymbols[biType] = symbol.clone();
  
      TParseContextBase::trackLinkage(symbol);
  }
  
  
  // Returns true if the built-in is a clip or cull distance variable.
  bool HlslParseContext::isClipOrCullDistance(TBuiltInVariable builtIn)
  {
      return builtIn == EbvClipDistance || builtIn == EbvCullDistance;
  }
  
  // Some types require fixed array sizes in SPIR-V, but can be scalars or
  // arrays of sizes SPIR-V doesn't allow.  For example, tessellation factors.
  // This creates the right size.  A conversion is performed when the internal
  // type is copied to or from the external type.  This corrects the externally
  // facing input or output type to abide downstream semantics.
  void HlslParseContext::fixBuiltInIoType(TType& type)
  {
      int requiredArraySize = 0;
      int requiredVectorSize = 0;
  
      switch (type.getQualifier().builtIn) {
      case EbvTessLevelOuter: requiredArraySize = 4; break;
      case EbvTessLevelInner: requiredArraySize = 2; break;
  
      case EbvSampleMask:
          {
              // Promote scalar to array of size 1.  Leave existing arrays alone.
              if (!type.isArray())
                  requiredArraySize = 1;
              break;
          }
  
      case EbvWorkGroupId:        requiredVectorSize = 3; break;
      case EbvGlobalInvocationId: requiredVectorSize = 3; break;
      case EbvLocalInvocationId:  requiredVectorSize = 3; break;
      case EbvTessCoord:          requiredVectorSize = 3; break;
  
      default:
          if (isClipOrCullDistance(type)) {
              const int loc = type.getQualifier().layoutLocation;
  
              if (type.getQualifier().builtIn == EbvClipDistance) {
                  if (type.getQualifier().storage == EvqVaryingIn)
                      clipSemanticNSizeIn[loc] = type.getVectorSize();
                  else
                      clipSemanticNSizeOut[loc] = type.getVectorSize();
              } else {
                  if (type.getQualifier().storage == EvqVaryingIn)
                      cullSemanticNSizeIn[loc] = type.getVectorSize();
                  else
                      cullSemanticNSizeOut[loc] = type.getVectorSize();
              }
          }
  
          return;
      }
  
      // Alter or set vector size as needed.
      if (requiredVectorSize > 0) {
          TType newType(type.getBasicType(), type.getQualifier().storage, requiredVectorSize);
          newType.getQualifier() = type.getQualifier();
  
          type.shallowCopy(newType);
      }
  
      // Alter or set array size as needed.
      if (requiredArraySize > 0) {
          if (!type.isArray() || type.getOuterArraySize() != requiredArraySize) {
              TArraySizes* arraySizes = new TArraySizes;
              arraySizes->addInnerSize(requiredArraySize);
              type.transferArraySizes(arraySizes);
          }
      }
  }
  
  // Variables that correspond to the user-interface in and out of a stage
  // (not the built-in interface) are
  //  - assigned locations
  //  - registered as a linkage node (part of the stage's external interface).
  // Assumes it is called in the order in which locations should be assigned.
  void HlslParseContext::assignToInterface(TVariable& variable)
  {
      const auto assignLocation = [&](TVariable& variable) {
          TType& type = variable.getWritableType();
          if (!type.isStruct() || type.getStruct()->size() > 0) {
              TQualifier& qualifier = type.getQualifier();
              if (qualifier.storage == EvqVaryingIn || qualifier.storage == EvqVaryingOut) {
                  if (qualifier.builtIn == EbvNone && !qualifier.hasLocation()) {
                      // Strip off the outer array dimension for those having an extra one.
                      int size;
                      if (type.isArray() && qualifier.isArrayedIo(language)) {
                          TType elementType(type, 0);
                          size = intermediate.computeTypeLocationSize(elementType, language);
                      } else
                          size = intermediate.computeTypeLocationSize(type, language);
  
                      if (qualifier.storage == EvqVaryingIn) {
                          variable.getWritableType().getQualifier().layoutLocation = nextInLocation;
                          nextInLocation += size;
                      } else {
                          variable.getWritableType().getQualifier().layoutLocation = nextOutLocation;
                          nextOutLocation += size;
                      }
                  }
                  trackLinkage(variable);
              }
          }
      };
  
      if (wasFlattened(variable.getUniqueId())) {
          auto& memberList = flattenMap[variable.getUniqueId()].members;
          for (auto member = memberList.begin(); member != memberList.end(); ++member)
              assignLocation(**member);
      } else if (wasSplit(variable.getUniqueId())) {
          TVariable* splitIoVar = getSplitNonIoVar(variable.getUniqueId());
          assignLocation(*splitIoVar);
      } else {
          assignLocation(variable);
      }
  }
  
  //
  // Handle seeing a function declarator in the grammar.  This is the precursor
  // to recognizing a function prototype or function definition.
  //
  void HlslParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunction& function, bool prototype)
  {
      //
      // Multiple declarations of the same function name are allowed.
      //
      // If this is a definition, the definition production code will check for redefinitions
      // (we don't know at this point if it's a definition or not).
      //
      bool builtIn;
      TSymbol* symbol = symbolTable.find(function.getMangledName(), &builtIn);
      const TFunction* prevDec = symbol ? symbol->getAsFunction() : 0;
  
      if (prototype) {
          // All built-in functions are defined, even though they don't have a body.
          // Count their prototype as a definition instead.
          if (symbolTable.atBuiltInLevel())
              function.setDefined();
          else {
              if (prevDec && ! builtIn)
                  symbol->getAsFunction()->setPrototyped();  // need a writable one, but like having prevDec as a const
              function.setPrototyped();
          }
      }
  
      // This insert won't actually insert it if it's a duplicate signature, but it will still check for
      // other forms of name collisions.
      if (! symbolTable.insert(function))
          error(loc, "function name is redeclaration of existing name", function.getName().c_str(), "");
  }
  
  // For struct buffers with counters, we must pass the counter buffer as hidden parameter.
  // This adds the hidden parameter to the parameter list in 'paramNodes' if needed.
  // Otherwise, it's a no-op
  void HlslParseContext::addStructBufferHiddenCounterParam(const TSourceLoc& loc, TParameter& param,
                                                           TIntermAggregate*& paramNodes)
  {
      if (! hasStructBuffCounter(*param.type))
          return;
  
      const TString counterBlockName(intermediate.addCounterBufferName(*param.name));
  
      TType counterType;
      counterBufferType(loc, counterType);
      TVariable *variable = makeInternalVariable(counterBlockName, counterType);
  
      if (! symbolTable.insert(*variable))
          error(loc, "redefinition", variable->getName().c_str(), "");
  
      paramNodes = intermediate.growAggregate(paramNodes,
                                              intermediate.addSymbol(*variable, loc),
                                              loc);
  }
  
  //
  // Handle seeing the function prototype in front of a function definition in the grammar.
  // The body is handled after this function returns.
  //
  // Returns an aggregate of parameter-symbol nodes.
  //
  TIntermAggregate* HlslParseContext::handleFunctionDefinition(const TSourceLoc& loc, TFunction& function,
                                                               const TAttributes& attributes,
                                                               TIntermNode*& entryPointTree)
  {
      currentCaller = function.getMangledName();
      TSymbol* symbol = symbolTable.find(function.getMangledName());
      TFunction* prevDec = symbol ? symbol->getAsFunction() : nullptr;
  
      if (prevDec == nullptr)
          error(loc, "can't find function", function.getName().c_str(), "");
      // Note:  'prevDec' could be 'function' if this is the first time we've seen function
      // as it would have just been put in the symbol table.  Otherwise, we're looking up
      // an earlier occurrence.
  
      if (prevDec && prevDec->isDefined()) {
          // Then this function already has a body.
          error(loc, "function already has a body", function.getName().c_str(), "");
      }
      if (prevDec && ! prevDec->isDefined()) {
          prevDec->setDefined();
  
          // Remember the return type for later checking for RETURN statements.
          currentFunctionType = &(prevDec->getType());
      } else
          currentFunctionType = new TType(EbtVoid);
      functionReturnsValue = false;
  
      // Entry points need different I/O and other handling, transform it so the
      // rest of this function doesn't care.
      entryPointTree = transformEntryPoint(loc, function, attributes);
  
      //
      // New symbol table scope for body of function plus its arguments
      //
      pushScope();
  
      //
      // Insert parameters into the symbol table.
      // If the parameter has no name, it's not an error, just don't insert it
      // (could be used for unused args).
      //
      // Also, accumulate the list of parameters into the AST, so lower level code
      // knows where to find parameters.
      //
      TIntermAggregate* paramNodes = new TIntermAggregate;
      for (int i = 0; i < function.getParamCount(); i++) {
          TParameter& param = function[i];
          if (param.name != nullptr) {
              TVariable *variable = new TVariable(param.name, *param.type);
  
              if (i == 0 && function.hasImplicitThis()) {
                  // Anonymous 'this' members are already in a symbol-table level,
                  // and we need to know what function parameter to map them to.
                  symbolTable.makeInternalVariable(*variable);
                  pushImplicitThis(variable);
              }
  
              // Insert the parameters with name in the symbol table.
              if (! symbolTable.insert(*variable))
                  error(loc, "redefinition", variable->getName().c_str(), "");
  
              // Add parameters to the AST list.
              if (shouldFlatten(variable->getType(), variable->getType().getQualifier().storage, true)) {
                  // Expand the AST parameter nodes (but not the name mangling or symbol table view)
                  // for structures that need to be flattened.
                  flatten(*variable, false);
                  const TTypeList* structure = variable->getType().getStruct();
                  for (int mem = 0; mem < (int)structure->size(); ++mem) {
                      paramNodes = intermediate.growAggregate(paramNodes,
                                                              flattenAccess(variable->getUniqueId(), mem,
                                                                            variable->getType().getQualifier().storage,
                                                                            *(*structure)[mem].type),
                                                              loc);
                  }
              } else {
                  // Add the parameter to the AST
                  paramNodes = intermediate.growAggregate(paramNodes,
                                                          intermediate.addSymbol(*variable, loc),
                                                          loc);
              }
  
              // Add hidden AST parameter for struct buffer counters, if needed.
              addStructBufferHiddenCounterParam(loc, param, paramNodes);
          } else
              paramNodes = intermediate.growAggregate(paramNodes, intermediate.addSymbol(*param.type, loc), loc);
      }
      if (function.hasIllegalImplicitThis())
          pushImplicitThis(nullptr);
  
      intermediate.setAggregateOperator(paramNodes, EOpParameters, TType(EbtVoid), loc);
      loopNestingLevel = 0;
      controlFlowNestingLevel = 0;
      postEntryPointReturn = false;
  
      return paramNodes;
  }
  
  // Handle all [attrib] attribute for the shader entry point
  void HlslParseContext::handleEntryPointAttributes(const TSourceLoc& loc, const TAttributes& attributes)
  {
      for (auto it = attributes.begin(); it != attributes.end(); ++it) {
          switch (it->name) {
          case EatNumThreads:
          {
              const TIntermSequence& sequence = it->args->getSequence();
              for (int lid = 0; lid < int(sequence.size()); ++lid)
                  intermediate.setLocalSize(lid, sequence[lid]->getAsConstantUnion()->getConstArray()[0].getIConst());
              break;
          }
          case EatMaxVertexCount:
          {
              int maxVertexCount;
  
              if (! it->getInt(maxVertexCount)) {
                  error(loc, "invalid maxvertexcount", "", "");
              } else {
                  if (! intermediate.setVertices(maxVertexCount))
                      error(loc, "cannot change previously set maxvertexcount attribute", "", "");
              }
              break;
          }
          case EatPatchConstantFunc:
          {
              TString pcfName;
              if (! it->getString(pcfName, 0, false)) {
                  error(loc, "invalid patch constant function", "", "");
              } else {
                  patchConstantFunctionName = pcfName;
              }
              break;
          }
          case EatDomain:
          {
              // Handle [domain("...")]
              TString domainStr;
              if (! it->getString(domainStr)) {
                  error(loc, "invalid domain", "", "");
              } else {
                  TLayoutGeometry domain = ElgNone;
  
                  if (domainStr == "tri") {
                      domain = ElgTriangles;
                  } else if (domainStr == "quad") {
                      domain = ElgQuads;
                  } else if (domainStr == "isoline") {
                      domain = ElgIsolines;
                  } else {
                      error(loc, "unsupported domain type", domainStr.c_str(), "");
                  }
  
                  if (language == EShLangTessEvaluation) {
                      if (! intermediate.setInputPrimitive(domain))
                          error(loc, "cannot change previously set domain", TQualifier::getGeometryString(domain), "");
                  } else {
                      if (! intermediate.setOutputPrimitive(domain))
                          error(loc, "cannot change previously set domain", TQualifier::getGeometryString(domain), "");
                  }
              }
              break;
          }
          case EatOutputTopology:
          {
              // Handle [outputtopology("...")]
              TString topologyStr;
              if (! it->getString(topologyStr)) {
                  error(loc, "invalid outputtopology", "", "");
              } else {
                  TVertexOrder vertexOrder = EvoNone;
                  TLayoutGeometry primitive = ElgNone;
  
                  if (topologyStr == "point") {
                      intermediate.setPointMode();
                  } else if (topologyStr == "line") {
                      primitive = ElgIsolines;
                  } else if (topologyStr == "triangle_cw") {
                      vertexOrder = EvoCw;
                      primitive = ElgTriangles;
                  } else if (topologyStr == "triangle_ccw") {
                      vertexOrder = EvoCcw;
                      primitive = ElgTriangles;
                  } else {
                      error(loc, "unsupported outputtopology type", topologyStr.c_str(), "");
                  }
  
                  if (vertexOrder != EvoNone) {
                      if (! intermediate.setVertexOrder(vertexOrder)) {
                          error(loc, "cannot change previously set outputtopology",
                                TQualifier::getVertexOrderString(vertexOrder), "");
                      }
                  }
                  if (primitive != ElgNone)
                      intermediate.setOutputPrimitive(primitive);
              }
              break;
          }
          case EatPartitioning:
          {
              // Handle [partitioning("...")]
              TString partitionStr;
              if (! it->getString(partitionStr)) {
                  error(loc, "invalid partitioning", "", "");
              } else {
                  TVertexSpacing partitioning = EvsNone;
                  
                  if (partitionStr == "integer") {
                      partitioning = EvsEqual;
                  } else if (partitionStr == "fractional_even") {
                      partitioning = EvsFractionalEven;
                  } else if (partitionStr == "fractional_odd") {
                      partitioning = EvsFractionalOdd;
                      //} else if (partition == "pow2") { // TODO: currently nothing to map this to.
                  } else {
                      error(loc, "unsupported partitioning type", partitionStr.c_str(), "");
                  }
  
                  if (! intermediate.setVertexSpacing(partitioning))
                      error(loc, "cannot change previously set partitioning",
                            TQualifier::getVertexSpacingString(partitioning), "");
              }
              break;
          }
          case EatOutputControlPoints:
          {
              // Handle [outputcontrolpoints("...")]
              int ctrlPoints;
              if (! it->getInt(ctrlPoints)) {
                  error(loc, "invalid outputcontrolpoints", "", "");
              } else {
                  if (! intermediate.setVertices(ctrlPoints)) {
                      error(loc, "cannot change previously set outputcontrolpoints attribute", "", "");
                  }
              }
              break;
          }
          case EatEarlyDepthStencil:
              intermediate.setEarlyFragmentTests();
              break;
          case EatBuiltIn:
          case EatLocation:
              // tolerate these because of dual use of entrypoint and type attributes
              break;
          default:
              warn(loc, "attribute does not apply to entry point", "", "");
              break;
          }
      }
  }
  
  // Update the given type with any type-like attribute information in the
  // attributes.
  void HlslParseContext::transferTypeAttributes(const TSourceLoc& loc, const TAttributes& attributes, TType& type,
      bool allowEntry)
  {
      if (attributes.size() == 0)
          return;
  
      int value;
      TString builtInString;
      for (auto it = attributes.begin(); it != attributes.end(); ++it) {
          switch (it->name) {
          case EatLocation:
              // location
              if (it->getInt(value))
                  type.getQualifier().layoutLocation = value;
              else
                  error(loc, "needs a literal integer", "location", "");
              break;
          case EatBinding:
              // binding
              if (it->getInt(value)) {
                  type.getQualifier().layoutBinding = value;
                  type.getQualifier().layoutSet = 0;
              } else
                  error(loc, "needs a literal integer", "binding", "");
              // set
              if (it->getInt(value, 1))
                  type.getQualifier().layoutSet = value;
              break;
          case EatGlobalBinding:
              // global cbuffer binding
              if (it->getInt(value))
                  globalUniformBinding = value;
              else
                  error(loc, "needs a literal integer", "global binding", "");
              // global cbuffer set
              if (it->getInt(value, 1))
                  globalUniformSet = value;
              break;
          case EatInputAttachment:
              // input attachment
              if (it->getInt(value))
                  type.getQualifier().layoutAttachment = value;
              else
                  error(loc, "needs a literal integer", "input attachment", "");
              break;
          case EatBuiltIn:
              // PointSize built-in
              if (it->getString(builtInString, 0, false)) {
                  if (builtInString == "PointSize")
                      type.getQualifier().builtIn = EbvPointSize;
              }
              break;
          case EatPushConstant:
              // push_constant
              type.getQualifier().layoutPushConstant = true;
              break;
          case EatConstantId:
              // specialization constant
              if (it->getInt(value)) {
                  TSourceLoc loc;
                  loc.init();
                  setSpecConstantId(loc, type.getQualifier(), value);
              }
              break;
  
          // image formats
          case EatFormatRgba32f:      type.getQualifier().layoutFormat = ElfRgba32f;      break;
          case EatFormatRgba16f:      type.getQualifier().layoutFormat = ElfRgba16f;      break;
          case EatFormatR32f:         type.getQualifier().layoutFormat = ElfR32f;         break;
          case EatFormatRgba8:        type.getQualifier().layoutFormat = ElfRgba8;        break;
          case EatFormatRgba8Snorm:   type.getQualifier().layoutFormat = ElfRgba8Snorm;   break;
          case EatFormatRg32f:        type.getQualifier().layoutFormat = ElfRg32f;        break;
          case EatFormatRg16f:        type.getQualifier().layoutFormat = ElfRg16f;        break;
          case EatFormatR11fG11fB10f: type.getQualifier().layoutFormat = ElfR11fG11fB10f; break;
          case EatFormatR16f:         type.getQualifier().layoutFormat = ElfR16f;         break;
          case EatFormatRgba16:       type.getQualifier().layoutFormat = ElfRgba16;       break;
          case EatFormatRgb10A2:      type.getQualifier().layoutFormat = ElfRgb10A2;      break;
          case EatFormatRg16:         type.getQualifier().layoutFormat = ElfRg16;         break;
          case EatFormatRg8:          type.getQualifier().layoutFormat = ElfRg8;          break;
          case EatFormatR16:          type.getQualifier().layoutFormat = ElfR16;          break;
          case EatFormatR8:           type.getQualifier().layoutFormat = ElfR8;           break;
          case EatFormatRgba16Snorm:  type.getQualifier().layoutFormat = ElfRgba16Snorm;  break;
          case EatFormatRg16Snorm:    type.getQualifier().layoutFormat = ElfRg16Snorm;    break;
          case EatFormatRg8Snorm:     type.getQualifier().layoutFormat = ElfRg8Snorm;     break;
          case EatFormatR16Snorm:     type.getQualifier().layoutFormat = ElfR16Snorm;     break;
          case EatFormatR8Snorm:      type.getQualifier().layoutFormat = ElfR8Snorm;      break;
          case EatFormatRgba32i:      type.getQualifier().layoutFormat = ElfRgba32i;      break;
          case EatFormatRgba16i:      type.getQualifier().layoutFormat = ElfRgba16i;      break;
          case EatFormatRgba8i:       type.getQualifier().layoutFormat = ElfRgba8i;       break;
          case EatFormatR32i:         type.getQualifier().layoutFormat = ElfR32i;         break;
          case EatFormatRg32i:        type.getQualifier().layoutFormat = ElfRg32i;        break;
          case EatFormatRg16i:        type.getQualifier().layoutFormat = ElfRg16i;        break;
          case EatFormatRg8i:         type.getQualifier().layoutFormat = ElfRg8i;         break;
          case EatFormatR16i:         type.getQualifier().layoutFormat = ElfR16i;         break;
          case EatFormatR8i:          type.getQualifier().layoutFormat = ElfR8i;          break;
          case EatFormatRgba32ui:     type.getQualifier().layoutFormat = ElfRgba32ui;     break;
          case EatFormatRgba16ui:     type.getQualifier().layoutFormat = ElfRgba16ui;     break;
          case EatFormatRgba8ui:      type.getQualifier().layoutFormat = ElfRgba8ui;      break;
          case EatFormatR32ui:        type.getQualifier().layoutFormat = ElfR32ui;        break;
          case EatFormatRgb10a2ui:    type.getQualifier().layoutFormat = ElfRgb10a2ui;    break;
          case EatFormatRg32ui:       type.getQualifier().layoutFormat = ElfRg32ui;       break;
          case EatFormatRg16ui:       type.getQualifier().layoutFormat = ElfRg16ui;       break;
          case EatFormatRg8ui:        type.getQualifier().layoutFormat = ElfRg8ui;        break;
          case EatFormatR16ui:        type.getQualifier().layoutFormat = ElfR16ui;        break;
          case EatFormatR8ui:         type.getQualifier().layoutFormat = ElfR8ui;         break;
          case EatFormatUnknown:      type.getQualifier().layoutFormat = ElfNone;         break;
  
          case EatNonWritable:  type.getQualifier().readonly = true;   break;
          case EatNonReadable:  type.getQualifier().writeonly = true;  break;
  
          default:
              if (! allowEntry)
                  warn(loc, "attribute does not apply to a type", "", "");
              break;
          }
      }
  }
  
  //
  // Do all special handling for the entry point, including wrapping
  // the shader's entry point with the official entry point that will call it.
  //
  // The following:
  //
  //    retType shaderEntryPoint(args...) // shader declared entry point
  //    { body }
  //
  // Becomes
  //
  //    out retType ret;
  //    in iargs<that are input>...;
  //    out oargs<that are output> ...;
  //
  //    void shaderEntryPoint()    // synthesized, but official, entry point
  //    {
  //        args<that are input> = iargs...;
  //        ret = @shaderEntryPoint(args...);
  //        oargs = args<that are output>...;
  //    }
  //    retType @shaderEntryPoint(args...)
  //    { body }
  //
  // The symbol table will still map the original entry point name to the
  // the modified function and its new name:
  //
  //    symbol table:  shaderEntryPoint  ->   @shaderEntryPoint
  //
  // Returns nullptr if no entry-point tree was built, otherwise, returns
  // a subtree that creates the entry point.
  //
  TIntermNode* HlslParseContext::transformEntryPoint(const TSourceLoc& loc, TFunction& userFunction,
                                                     const TAttributes& attributes)
  {
      // Return true if this is a tessellation patch constant function input to a domain shader.
      const auto isDsPcfInput = [this](const TType& type) {
          return language == EShLangTessEvaluation &&
          type.contains([](const TType* t) {
                  return t->getQualifier().builtIn == EbvTessLevelOuter ||
                         t->getQualifier().builtIn == EbvTessLevelInner;
              });
      };
  
      // if we aren't in the entry point, fix the IO as such and exit
      if (! isEntrypointName(userFunction.getName())) {
          remapNonEntryPointIO(userFunction);
          return nullptr;
      }
  
      entryPointFunction = &userFunction; // needed in finish()
  
      // Handle entry point attributes
      handleEntryPointAttributes(loc, attributes);
  
      // entry point logic...
  
      // Move parameters and return value to shader in/out
      TVariable* entryPointOutput; // gets created in remapEntryPointIO
      TVector<TVariable*> inputs;
      TVector<TVariable*> outputs;
      remapEntryPointIO(userFunction, entryPointOutput, inputs, outputs);
  
      // Further this return/in/out transform by flattening, splitting, and assigning locations
      const auto makeVariableInOut = [&](TVariable& variable) {
          if (variable.getType().isStruct()) {
              if (variable.getType().getQualifier().isArrayedIo(language)) {
                  if (variable.getType().containsBuiltIn())
                      split(variable);
              } else if (shouldFlatten(variable.getType(), EvqVaryingIn /* not assigned yet, but close enough */, true))
                  flatten(variable, false /* don't track linkage here, it will be tracked in assignToInterface() */);
          }
          // TODO: flatten arrays too
          // TODO: flatten everything in I/O
          // TODO: replace all split with flatten, make all paths can create flattened I/O, then split code can be removed
  
          // For clip and cull distance, multiple output variables potentially get merged
          // into one in assignClipCullDistance.  That code in assignClipCullDistance
          // handles the interface logic, so we avoid it here in that case.
          if (!isClipOrCullDistance(variable.getType()))
              assignToInterface(variable);
      };
      if (entryPointOutput != nullptr)
          makeVariableInOut(*entryPointOutput);
      for (auto it = inputs.begin(); it != inputs.end(); ++it)
          if (!isDsPcfInput((*it)->getType()))  // wait until the end for PCF input (see comment below)
              makeVariableInOut(*(*it));
      for (auto it = outputs.begin(); it != outputs.end(); ++it)
          makeVariableInOut(*(*it));
  
      // In the domain shader, PCF input must be at the end of the linkage.  That's because in the
      // hull shader there is no ordering: the output comes from the separate PCF, which does not
      // participate in the argument list.  That is always put at the end of the HS linkage, so the
      // input side of the DS must match.  The argument may be in any position in the DS argument list
      // however, so this ensures the linkage is built in the correct order regardless of argument order.
      if (language == EShLangTessEvaluation) {
          for (auto it = inputs.begin(); it != inputs.end(); ++it)
              if (isDsPcfInput((*it)->getType()))
                  makeVariableInOut(*(*it));
      }
  
      // Synthesize the call
  
      pushScope(); // matches the one in handleFunctionBody()
  
      // new signature
      TType voidType(EbtVoid);
      TFunction synthEntryPoint(&userFunction.getName(), voidType);
      TIntermAggregate* synthParams = new TIntermAggregate();
      intermediate.setAggregateOperator(synthParams, EOpParameters, voidType, loc);
      intermediate.setEntryPointMangledName(synthEntryPoint.getMangledName().c_str());
      intermediate.incrementEntryPointCount();
      TFunction callee(&userFunction.getName(), voidType); // call based on old name, which is still in the symbol table
  
      // change original name
      userFunction.addPrefix("@");                         // change the name in the function, but not in the symbol table
  
      // Copy inputs (shader-in -> calling arg), while building up the call node
      TVector<TVariable*> argVars;
      TIntermAggregate* synthBody = new TIntermAggregate();
      auto inputIt = inputs.begin();
      TIntermTyped* callingArgs = nullptr;
  
      for (int i = 0; i < userFunction.getParamCount(); i++) {
          TParameter& param = userFunction[i];
          argVars.push_back(makeInternalVariable(*param.name, *param.type));
          argVars.back()->getWritableType().getQualifier().makeTemporary();
  
          // Track the input patch, which is the only non-builtin supported by hull shader PCF.
          if (param.getDeclaredBuiltIn() == EbvInputPatch)
              inputPatch = argVars.back();
  
          TIntermSymbol* arg = intermediate.addSymbol(*argVars.back());
          handleFunctionArgument(&callee, callingArgs, arg);
          if (param.type->getQualifier().isParamInput()) {
              intermediate.growAggregate(synthBody, handleAssign(loc, EOpAssign, arg,
                                                                 intermediate.addSymbol(**inputIt)));
              inputIt++;
          }
      }
  
      // Call
      currentCaller = synthEntryPoint.getMangledName();
      TIntermTyped* callReturn = handleFunctionCall(loc, &callee, callingArgs);
      currentCaller = userFunction.getMangledName();
  
      // Return value
      if (entryPointOutput) {
          TIntermTyped* returnAssign;
  
          // For hull shaders, the wrapped entry point return value is written to
          // an array element as indexed by invocation ID, which we might have to make up.
          // This is required to match SPIR-V semantics.
          if (language == EShLangTessControl) {
              TIntermSymbol* invocationIdSym = findTessLinkageSymbol(EbvInvocationId);
  
              // If there is no user declared invocation ID, we must make one.
              if (invocationIdSym == nullptr) {
                  TType invocationIdType(EbtUint, EvqIn, 1);
                  TString* invocationIdName = NewPoolTString("InvocationId");
                  invocationIdType.getQualifier().builtIn = EbvInvocationId;
  
                  TVariable* variable = makeInternalVariable(*invocationIdName, invocationIdType);
  
                  globalQualifierFix(loc, variable->getWritableType().getQualifier());
                  trackLinkage(*variable);
  
                  invocationIdSym = intermediate.addSymbol(*variable);
              }
  
              TIntermTyped* element = intermediate.addIndex(EOpIndexIndirect, intermediate.addSymbol(*entryPointOutput),
                                                            invocationIdSym, loc);
  
              // Set the type of the array element being dereferenced
              const TType derefElementType(entryPointOutput->getType(), 0);
              element->setType(derefElementType);
  
              returnAssign = handleAssign(loc, EOpAssign, element, callReturn);
          } else {
              returnAssign = handleAssign(loc, EOpAssign, intermediate.addSymbol(*entryPointOutput), callReturn);
          }
          intermediate.growAggregate(synthBody, returnAssign);
      } else
          intermediate.growAggregate(synthBody, callReturn);
  
      // Output copies
      auto outputIt = outputs.begin();
      for (int i = 0; i < userFunction.getParamCount(); i++) {
          TParameter& param = userFunction[i];
  
          // GS outputs are via emit, so we do not copy them here.
          if (param.type->getQualifier().isParamOutput()) {
              if (param.getDeclaredBuiltIn() == EbvGsOutputStream) {
                  // GS output stream does not assign outputs here: it's the Append() method
                  // which writes to the output, probably multiple times separated by Emit.
                  // We merely remember the output to use, here.
                  gsStreamOutput = *outputIt;
              } else {
                  intermediate.growAggregate(synthBody, handleAssign(loc, EOpAssign,
                                                                     intermediate.addSymbol(**outputIt),
                                                                     intermediate.addSymbol(*argVars[i])));
              }
  
              outputIt++;
          }
      }
  
      // Put the pieces together to form a full function subtree
      // for the synthesized entry point.
      synthBody->setOperator(EOpSequence);
      TIntermNode* synthFunctionDef = synthParams;
      handleFunctionBody(loc, synthEntryPoint, synthBody, synthFunctionDef);
  
      entryPointFunctionBody = synthBody;
  
      return synthFunctionDef;
  }
  
  void HlslParseContext::handleFunctionBody(const TSourceLoc& loc, TFunction& function, TIntermNode* functionBody,
                                            TIntermNode*& node)
  {
      node = intermediate.growAggregate(node, functionBody);
      intermediate.setAggregateOperator(node, EOpFunction, function.getType(), loc);
      node->getAsAggregate()->setName(function.getMangledName().c_str());
  
      popScope();
      if (function.hasImplicitThis())
          popImplicitThis();
  
      if (function.getType().getBasicType() != EbtVoid && ! functionReturnsValue)
          error(loc, "function does not return a value:", "", function.getName().c_str());
  }
  
  // AST I/O is done through shader globals declared in the 'in' or 'out'
  // storage class.  An HLSL entry point has a return value, input parameters
  // and output parameters.  These need to get remapped to the AST I/O.
  void HlslParseContext::remapEntryPointIO(TFunction& function, TVariable*& returnValue,
      TVector<TVariable*>& inputs, TVector<TVariable*>& outputs)
  {
      // We might have in input structure type with no decorations that caused it
      // to look like an input type, yet it has (e.g.) interpolation types that
      // must be modified that turn it into an input type.
      // Hence, a missing ioTypeMap for 'input' might need to be synthesized.
      const auto synthesizeEditedInput = [this](TType& type) {
          // True if a type needs to be 'flat'
          const auto needsFlat = [](const TType& type) {
              return type.containsBasicType(EbtInt) ||
                      type.containsBasicType(EbtUint) ||
                      type.containsBasicType(EbtInt64) ||
                      type.containsBasicType(EbtUint64) ||
                      type.containsBasicType(EbtBool) ||
                      type.containsBasicType(EbtDouble);
          };
  
          if (language == EShLangFragment && needsFlat(type)) {
              if (type.isStruct()) {
                  TTypeList* finalList = nullptr;
                  auto it = ioTypeMap.find(type.getStruct());
                  if (it == ioTypeMap.end() || it->second.input == nullptr) {
                      // Getting here means we have no input struct, but we need one.
                      auto list = new TTypeList;
                      for (auto member = type.getStruct()->begin(); member != type.getStruct()->end(); ++member) {
                          TType* newType = new TType;
                          newType->shallowCopy(*member->type);
                          TTypeLoc typeLoc = { newType, member->loc };
                          list->push_back(typeLoc);
                      }
                      // install the new input type
                      if (it == ioTypeMap.end()) {
                          tIoKinds newLists = { list, nullptr, nullptr };
                          ioTypeMap[type.getStruct()] = newLists;
                      } else
                          it->second.input = list;
                      finalList = list;
                  } else
                      finalList = it->second.input;
                  // edit for 'flat'
                  for (auto member = finalList->begin(); member != finalList->end(); ++member) {
                      if (needsFlat(*member->type)) {
                          member->type->getQualifier().clearInterpolation();
                          member->type->getQualifier().flat = true;
                      }
                  }
              } else {
                  type.getQualifier().clearInterpolation();
                  type.getQualifier().flat = true;
              }
          }
      };
  
      // Do the actual work to make a type be a shader input or output variable,
      // and clear the original to be non-IO (for use as a normal function parameter/return).
      const auto makeIoVariable = [this](const char* name, TType& type, TStorageQualifier storage) -> TVariable* {
          TVariable* ioVariable = makeInternalVariable(name, type);
          clearUniformInputOutput(type.getQualifier());
          if (type.isStruct()) {
              auto newLists = ioTypeMap.find(ioVariable->getType().getStruct());
              if (newLists != ioTypeMap.end()) {
                  if (storage == EvqVaryingIn && newLists->second.input)
                      ioVariable->getWritableType().setStruct(newLists->second.input);
                  else if (storage == EvqVaryingOut && newLists->second.output)
                      ioVariable->getWritableType().setStruct(newLists->second.output);
              }
          }
          if (storage == EvqVaryingIn) {
              correctInput(ioVariable->getWritableType().getQualifier());
              if (language == EShLangTessEvaluation)
                  if (!ioVariable->getType().isArray())
                      ioVariable->getWritableType().getQualifier().patch = true;
          } else {
              correctOutput(ioVariable->getWritableType().getQualifier());
          }
          ioVariable->getWritableType().getQualifier().storage = storage;
  
          fixBuiltInIoType(ioVariable->getWritableType());
  
          return ioVariable;
      };
  
      // return value is actually a shader-scoped output (out)
      if (function.getType().getBasicType() == EbtVoid) {
          returnValue = nullptr;
      } else {
          if (language == EShLangTessControl) {
              // tessellation evaluation in HLSL writes a per-ctrl-pt value, but it needs to be an
              // array in SPIR-V semantics.  We'll write to it indexed by invocation ID.
  
              returnValue = makeIoVariable("@entryPointOutput", function.getWritableType(), EvqVaryingOut);
  
              TType outputType;
              outputType.shallowCopy(function.getType());
  
              // vertices has necessarily already been set when handling entry point attributes.
              TArraySizes* arraySizes = new TArraySizes;
              arraySizes->addInnerSize(intermediate.getVertices());
              outputType.transferArraySizes(arraySizes);
  
              clearUniformInputOutput(function.getWritableType().getQualifier());
              returnValue = makeIoVariable("@entryPointOutput", outputType, EvqVaryingOut);
          } else {
              returnValue = makeIoVariable("@entryPointOutput", function.getWritableType(), EvqVaryingOut);
          }
      }
  
      // parameters are actually shader-scoped inputs and outputs (in or out)
      for (int i = 0; i < function.getParamCount(); i++) {
          TType& paramType = *function[i].type;
          if (paramType.getQualifier().isParamInput()) {
              synthesizeEditedInput(paramType);
              TVariable* argAsGlobal = makeIoVariable(function[i].name->c_str(), paramType, EvqVaryingIn);
              inputs.push_back(argAsGlobal);
          }
          if (paramType.getQualifier().isParamOutput()) {
              TVariable* argAsGlobal = makeIoVariable(function[i].name->c_str(), paramType, EvqVaryingOut);
              outputs.push_back(argAsGlobal);
          }
      }
  }
  
  // An HLSL function that looks like an entry point, but is not,
  // declares entry point IO built-ins, but these have to be undone.
  void HlslParseContext::remapNonEntryPointIO(TFunction& function)
  {
      // return value
      if (function.getType().getBasicType() != EbtVoid)
          clearUniformInputOutput(function.getWritableType().getQualifier());
  
      // parameters.
      // References to structuredbuffer types are left unmodified
      for (int i = 0; i < function.getParamCount(); i++)
          if (!isReference(*function[i].type))
              clearUniformInputOutput(function[i].type->getQualifier());
  }
  
  // Handle function returns, including type conversions to the function return type
  // if necessary.
  TIntermNode* HlslParseContext::handleReturnValue(const TSourceLoc& loc, TIntermTyped* value)
  {
      functionReturnsValue = true;
  
      if (currentFunctionType->getBasicType() == EbtVoid) {
          error(loc, "void function cannot return a value", "return", "");
          return intermediate.addBranch(EOpReturn, loc);
      } else if (*currentFunctionType != value->getType()) {
          value = intermediate.addConversion(EOpReturn, *currentFunctionType, value);
          if (value && *currentFunctionType != value->getType())
              value = intermediate.addUniShapeConversion(EOpReturn, *currentFunctionType, value);
          if (value == nullptr || *currentFunctionType != value->getType()) {
              error(loc, "type does not match, or is not convertible to, the function's return type", "return", "");
              return value;
          }
      }
  
      return intermediate.addBranch(EOpReturn, value, loc);
  }
  
  void HlslParseContext::handleFunctionArgument(TFunction* function,
                                                TIntermTyped*& arguments, TIntermTyped* newArg)
  {
      TParameter param = { 0, new TType, nullptr };
      param.type->shallowCopy(newArg->getType());
  
      function->addParameter(param);
      if (arguments)
          arguments = intermediate.growAggregate(arguments, newArg);
      else
          arguments = newArg;
  }
  
  // Position may require special handling: we can optionally invert Y.
  // See: https://github.com/KhronosGroup/glslang/issues/1173
  //      https://github.com/KhronosGroup/glslang/issues/494
  TIntermTyped* HlslParseContext::assignPosition(const TSourceLoc& loc, TOperator op,
                                                 TIntermTyped* left, TIntermTyped* right)
  {
      // If we are not asked for Y inversion, use a plain old assign.
      if (!intermediate.getInvertY())
          return intermediate.addAssign(op, left, right, loc);
  
      // If we get here, we should invert Y.
      TIntermAggregate* assignList = nullptr;
  
      // If this is a complex rvalue, we don't want to dereference it many times.  Create a temporary.
      TVariable* rhsTempVar = nullptr;
      rhsTempVar = makeInternalVariable("@position", right->getType());
      rhsTempVar->getWritableType().getQualifier().makeTemporary();
  
      {
          TIntermTyped* rhsTempSym = intermediate.addSymbol(*rhsTempVar, loc);
          assignList = intermediate.growAggregate(assignList,
                                                  intermediate.addAssign(EOpAssign, rhsTempSym, right, loc), loc);
      }
  
      // pos.y = -pos.y
      {
          const int Y = 1;
  
          TIntermTyped* tempSymL = intermediate.addSymbol(*rhsTempVar, loc);
          TIntermTyped* tempSymR = intermediate.addSymbol(*rhsTempVar, loc);
          TIntermTyped* index = intermediate.addConstantUnion(Y, loc);
  
          TIntermTyped* lhsElement = intermediate.addIndex(EOpIndexDirect, tempSymL, index, loc);
          TIntermTyped* rhsElement = intermediate.addIndex(EOpIndexDirect, tempSymR, index, loc);
  
          const TType derefType(right->getType(), 0);
      
          lhsElement->setType(derefType);
          rhsElement->setType(derefType);
  
          TIntermTyped* yNeg = intermediate.addUnaryMath(EOpNegative, rhsElement, loc);
  
          assignList = intermediate.growAggregate(assignList, intermediate.addAssign(EOpAssign, lhsElement, yNeg, loc));
      }
  
      // Assign the rhs temp (now with Y inversion) to the final output
      {
          TIntermTyped* rhsTempSym = intermediate.addSymbol(*rhsTempVar, loc);
          assignList = intermediate.growAggregate(assignList, intermediate.addAssign(op, left, rhsTempSym, loc));
      }
  
      assert(assignList != nullptr);
      assignList->setOperator(EOpSequence);
  
      return assignList;
  }
      
  // Clip and cull distance require special handling due to a semantic mismatch.  In HLSL,
  // these can be float scalar, float vector, or arrays of float scalar or float vector.
  // In SPIR-V, they are arrays of scalar floats in all cases.  We must copy individual components
  // (e.g, both x and y components of a float2) out into the destination float array.
  //
  // The values are assigned to sequential members of the output array.  The inner dimension
  // is vector components.  The outer dimension is array elements.
  TIntermAggregate* HlslParseContext::assignClipCullDistance(const TSourceLoc& loc, TOperator op, int semanticId,
                                                             TIntermTyped* left, TIntermTyped* right)
  {
      switch (language) {
      case EShLangFragment:
      case EShLangVertex:
      case EShLangGeometry:
          break;
      default:
          error(loc, "unimplemented: clip/cull not currently implemented for this stage", "", "");
          return nullptr;
      }
  
      TVariable** clipCullVar = nullptr;
  
      // Figure out if we are assigning to, or from, clip or cull distance.
      const bool isOutput = isClipOrCullDistance(left->getType());
  
      // This is the rvalue or lvalue holding the clip or cull distance.
      TIntermTyped* clipCullNode = isOutput ? left : right;
      // This is the value going into or out of the clip or cull distance.
      TIntermTyped* internalNode = isOutput ? right : left;
  
      const TBuiltInVariable builtInType = clipCullNode->getQualifier().builtIn;
  
      decltype(clipSemanticNSizeIn)* semanticNSize = nullptr;
  
      // Refer to either the clip or the cull distance, depending on semantic.
      switch (builtInType) {
      case EbvClipDistance:
          clipCullVar = isOutput ? &clipDistanceOutput : &clipDistanceInput;
          semanticNSize = isOutput ? &clipSemanticNSizeOut : &clipSemanticNSizeIn;
          break;
      case EbvCullDistance:
          clipCullVar = isOutput ? &cullDistanceOutput : &cullDistanceInput;
          semanticNSize = isOutput ? &cullSemanticNSizeOut : &cullSemanticNSizeIn;
          break;
  
      // called invalidly: we expected a clip or a cull distance.
      // static compile time problem: should not happen.
      default: assert(0); return nullptr;
      }
  
      // This is the offset in the destination array of a given semantic's data
      std::array<int, maxClipCullRegs> semanticOffset;
  
      // Calculate offset of variable of semantic N in destination array
      int arrayLoc = 0;
      int vecItems = 0;
  
      for (int x = 0; x < maxClipCullRegs; ++x) {
          // See if we overflowed the vec4 packing
          if ((vecItems + (*semanticNSize)[x]) > 4) {
              arrayLoc = (arrayLoc + 3) & (~0x3); // round up to next multiple of 4
              vecItems = 0;
          }
  
          semanticOffset[x] = arrayLoc;
          vecItems += (*semanticNSize)[x];
          arrayLoc += (*semanticNSize)[x];
      }
   
  
      // It can have up to 2 array dimensions (in the case of geometry shader inputs)
      const TArraySizes* const internalArraySizes = internalNode->getType().getArraySizes();
      const int internalArrayDims = internalNode->getType().isArray() ? internalArraySizes->getNumDims() : 0;
      // vector sizes:
      const int internalVectorSize = internalNode->getType().getVectorSize();
      // array sizes, or 1 if it's not an array:
      const int internalInnerArraySize = (internalArrayDims > 0 ? internalArraySizes->getDimSize(internalArrayDims-1) : 1);
      const int internalOuterArraySize = (internalArrayDims > 1 ? internalArraySizes->getDimSize(0) : 1);
  
      // The created type may be an array of arrays, e.g, for geometry shader inputs.
      const bool isImplicitlyArrayed = (language == EShLangGeometry && !isOutput);
  
      // If we haven't created the output already, create it now.
      if (*clipCullVar == nullptr) {
          // ClipDistance and CullDistance are handled specially in the entry point input/output copy
          // algorithm, because they may need to be unpacked from components of vectors (or a scalar)
          // into a float array, or vice versa.  Here, we make the array the right size and type,
          // which depends on the incoming data, which has several potential dimensions:
          //    * Semantic ID
          //    * vector size 
          //    * array size
          // Of those, semantic ID and array size cannot appear simultaneously.
          //
          // Also to note: for implicitly arrayed forms (e.g, geometry shader inputs), we need to create two
          // array dimensions.  The shader's declaration may have one or two array dimensions.  One is always
          // the geometry's dimension.
  
          const bool useInnerSize = internalArrayDims > 1 || !isImplicitlyArrayed;
  
          const int requiredInnerArraySize = arrayLoc * (useInnerSize ? internalInnerArraySize : 1);
          const int requiredOuterArraySize = (internalArrayDims > 0) ? internalArraySizes->getDimSize(0) : 1;
  
          TType clipCullType(EbtFloat, clipCullNode->getType().getQualifier().storage, 1);
          clipCullType.getQualifier() = clipCullNode->getType().getQualifier();
  
          // Create required array dimension
          TArraySizes* arraySizes = new TArraySizes;
          if (isImplicitlyArrayed)
              arraySizes->addInnerSize(requiredOuterArraySize);
          arraySizes->addInnerSize(requiredInnerArraySize);
          clipCullType.transferArraySizes(arraySizes);
  
          // Obtain symbol name: we'll use that for the symbol we introduce.
          TIntermSymbol* sym = clipCullNode->getAsSymbolNode();
          assert(sym != nullptr);
  
          // We are moving the semantic ID from the layout location, so it is no longer needed or
          // desired there.
          clipCullType.getQualifier().layoutLocation = TQualifier::layoutLocationEnd;
  
          // Create variable and track its linkage
          *clipCullVar = makeInternalVariable(sym->getName().c_str(), clipCullType);
  
          trackLinkage(**clipCullVar);
      }
  
      // Create symbol for the clip or cull variable.
      TIntermSymbol* clipCullSym = intermediate.addSymbol(**clipCullVar);
  
      // vector sizes:
      const int clipCullVectorSize = clipCullSym->getType().getVectorSize();
  
      // array sizes, or 1 if it's not an array:
      const TArraySizes* const clipCullArraySizes = clipCullSym->getType().getArraySizes();
      const int clipCullOuterArraySize = isImplicitlyArrayed ? clipCullArraySizes->getDimSize(0) : 1;
      const int clipCullInnerArraySize = clipCullArraySizes->getDimSize(isImplicitlyArrayed ? 1 : 0);
  
      // clipCullSym has got to be an array of scalar floats, per SPIR-V semantics.
      // fixBuiltInIoType() should have handled that upstream.
      assert(clipCullSym->getType().isArray());
      assert(clipCullSym->getType().getVectorSize() == 1);
      assert(clipCullSym->getType().getBasicType() == EbtFloat);
  
      // We may be creating multiple sub-assignments.  This is an aggregate to hold them.
      // TODO: it would be possible to be clever sometimes and avoid the sequence node if not needed.
      TIntermAggregate* assignList = nullptr;
  
      // Holds individual component assignments as we make them.
      TIntermTyped* clipCullAssign = nullptr;
  
      // If the types are homomorphic, use a simple assign.  No need to mess about with 
      // individual components.
      if (clipCullSym->getType().isArray() == internalNode->getType().isArray() &&
          clipCullInnerArraySize == internalInnerArraySize &&
          clipCullOuterArraySize == internalOuterArraySize &&
          clipCullVectorSize == internalVectorSize) {
  
          if (isOutput)
              clipCullAssign = intermediate.addAssign(op, clipCullSym, internalNode, loc);
          else
              clipCullAssign = intermediate.addAssign(op, internalNode, clipCullSym, loc);
  
          assignList = intermediate.growAggregate(assignList, clipCullAssign);
          assignList->setOperator(EOpSequence);
  
          return assignList;
      }
  
      // We are going to copy each component of the internal (per array element if indicated) to sequential
      // array elements of the clipCullSym.  This tracks the lhs element we're writing to as we go along.
      // We may be starting in the middle - e.g, for a non-zero semantic ID calculated above.
      int clipCullInnerArrayPos = semanticOffset[semanticId];
      int clipCullOuterArrayPos = 0;
  
      // Lambda to add an index to a node, set the type of the result, and return the new node.
      const auto addIndex = [this, &loc](TIntermTyped* node, int pos) -> TIntermTyped* {
          const TType derefType(node->getType(), 0);
          node = intermediate.addIndex(EOpIndexDirect, node, intermediate.addConstantUnion(pos, loc), loc);
          node->setType(derefType);
          return node;
      };
  
      // Loop through every component of every element of the internal, and copy to or from the matching external.
      for (int internalOuterArrayPos = 0; internalOuterArrayPos < internalOuterArraySize; ++internalOuterArrayPos) {
          for (int internalInnerArrayPos = 0; internalInnerArrayPos < internalInnerArraySize; ++internalInnerArrayPos) {
              for (int internalComponent = 0; internalComponent < internalVectorSize; ++internalComponent) {
                  // clip/cull array member to read from / write to:
                  TIntermTyped* clipCullMember = clipCullSym;
  
                  // If implicitly arrayed, there is an outer array dimension involved
                  if (isImplicitlyArrayed)
                      clipCullMember = addIndex(clipCullMember, clipCullOuterArrayPos);
  
                  // Index into proper array position for clip cull member
                  clipCullMember = addIndex(clipCullMember, clipCullInnerArrayPos++);
  
                  // if needed, start over with next outer array slice.
                  if (isImplicitlyArrayed && clipCullInnerArrayPos >= clipCullInnerArraySize) {
                      clipCullInnerArrayPos = semanticOffset[semanticId];
                      ++clipCullOuterArrayPos;
                  }
  
                  // internal member to read from / write to:
                  TIntermTyped* internalMember = internalNode;
  
                  // If internal node has outer array dimension, index appropriately.
                  if (internalArrayDims > 1)
                      internalMember = addIndex(internalMember, internalOuterArrayPos);
  
                  // If internal node has inner array dimension, index appropriately.
                  if (internalArrayDims > 0)
                      internalMember = addIndex(internalMember, internalInnerArrayPos);
  
                  // If internal node is a vector, extract the component of interest.
                  if (internalNode->getType().isVector())
                      internalMember = addIndex(internalMember, internalComponent);
  
                  // Create an assignment: output from internal to clip cull, or input from clip cull to internal.
                  if (isOutput)
                      clipCullAssign = intermediate.addAssign(op, clipCullMember, internalMember, loc);
                  else
                      clipCullAssign = intermediate.addAssign(op, internalMember, clipCullMember, loc);
  
                  // Track assignment in the sequence.
                  assignList = intermediate.growAggregate(assignList, clipCullAssign);
              }
          }
      }
  
      assert(assignList != nullptr);
      assignList->setOperator(EOpSequence);
  
      return assignList;
  }
  
  // Some simple source assignments need to be flattened to a sequence
  // of AST assignments. Catch these and flatten, otherwise, pass through
  // to intermediate.addAssign().
  //
  // Also, assignment to matrix swizzles requires multiple component assignments,
  // intercept those as well.
  TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op, TIntermTyped* left,
                                               TIntermTyped* right)
  {
      if (left == nullptr || right == nullptr)
          return nullptr;
  
      // writing to opaques will require fixing transforms
      if (left->getType().containsOpaque())
          intermediate.setNeedsLegalization();
  
      if (left->getAsOperator() && left->getAsOperator()->getOp() == EOpMatrixSwizzle)
          return handleAssignToMatrixSwizzle(loc, op, left, right);
  
      // Return true if the given node is an index operation into a split variable.
      const auto indexesSplit = [this](const TIntermTyped* node) -> bool {
          const TIntermBinary* binaryNode = node->getAsBinaryNode();
  
          if (binaryNode == nullptr)
              return false;
  
          return (binaryNode->getOp() == EOpIndexDirect || binaryNode->getOp() == EOpIndexIndirect) && 
                 wasSplit(binaryNode->getLeft());
      };
  
      // Return true if this stage assigns clip position with potentially inverted Y
      const auto assignsClipPos = [this](const TIntermTyped* node) -> bool {
          return node->getType().getQualifier().builtIn == EbvPosition &&
                 (language == EShLangVertex || language == EShLangGeometry || language == EShLangTessEvaluation);
      };
  
      const bool isSplitLeft    = wasSplit(left) || indexesSplit(left);
      const bool isSplitRight   = wasSplit(right) || indexesSplit(right);
  
      const bool isFlattenLeft  = wasFlattened(left);
      const bool isFlattenRight = wasFlattened(right);
  
      // OK to do a single assign if neither side is split or flattened.  Otherwise, 
      // fall through to a member-wise copy.
      if (!isFlattenLeft && !isFlattenRight && !isSplitLeft && !isSplitRight) {
          // Clip and cull distance requires more processing.  See comment above assignClipCullDistance.
          if (isClipOrCullDistance(left->getType()) || isClipOrCullDistance(right->getType())) {
              const bool isOutput = isClipOrCullDistance(left->getType());
  
              const int semanticId = (isOutput ? left : right)->getType().getQualifier().layoutLocation;
              return assignClipCullDistance(loc, op, semanticId, left, right);
          } else if (assignsClipPos(left)) {
              // Position can require special handling: see comment above assignPosition
              return assignPosition(loc, op, left, right);
          } else if (left->getQualifier().builtIn == EbvSampleMask) {
              // Certain builtins are required to be arrayed outputs in SPIR-V, but may internally be scalars
              // in the shader.  Copy the scalar RHS into the LHS array element zero, if that happens.
              if (left->isArray() && !right->isArray()) {
                  const TType derefType(left->getType(), 0);
                  left = intermediate.addIndex(EOpIndexDirect, left, intermediate.addConstantUnion(0, loc), loc);
                  left->setType(derefType);
                  // Fall through to add assign.
              }
          }
  
          return intermediate.addAssign(op, left, right, loc);
      }
  
      TIntermAggregate* assignList = nullptr;
      const TVector<TVariable*>* leftVariables = nullptr;
      const TVector<TVariable*>* rightVariables = nullptr;
  
      // A temporary to store the right node's value, so we don't keep indirecting into it
      // if it's not a simple symbol.
      TVariable* rhsTempVar = nullptr;
  
      // If the RHS is a simple symbol node, we'll copy it for each member.
      TIntermSymbol* cloneSymNode = nullptr;
  
      int memberCount = 0;
  
      // Track how many items there are to copy.
      if (left->getType().isStruct())
          memberCount = (int)left->getType().getStruct()->size();
      if (left->getType().isArray())
          memberCount = left->getType().getCumulativeArraySize();
  
      if (isFlattenLeft)
          leftVariables = &flattenMap.find(left->getAsSymbolNode()->getId())->second.members;
  
      if (isFlattenRight) {
          rightVariables = &flattenMap.find(right->getAsSymbolNode()->getId())->second.members;
      } else {
          // The RHS is not flattened.  There are several cases:
          // 1. 1 item to copy:  Use the RHS directly.
          // 2. >1 item, simple symbol RHS: we'll create a new TIntermSymbol node for each, but no assign to temp.
          // 3. >1 item, complex RHS: assign it to a new temp variable, and create a TIntermSymbol for each member.
  
          if (memberCount <= 1) {
              // case 1: we'll use the symbol directly below.  Nothing to do.
          } else {
              if (right->getAsSymbolNode() != nullptr) {
                  // case 2: we'll copy the symbol per iteration below.
                  cloneSymNode = right->getAsSymbolNode();
              } else {
                  // case 3: assign to a temp, and indirect into that.
                  rhsTempVar = makeInternalVariable("flattenTemp", right->getType());
                  rhsTempVar->getWritableType().getQualifier().makeTemporary();
                  TIntermTyped* noFlattenRHS = intermediate.addSymbol(*rhsTempVar, loc);
  
                  // Add this to the aggregate being built.
                  assignList = intermediate.growAggregate(assignList,
                                                          intermediate.addAssign(op, noFlattenRHS, right, loc), loc);
              }
          }
      }
  
      // When dealing with split arrayed structures of built-ins, the arrayness is moved to the extracted built-in
      // variables, which is awkward when copying between split and unsplit structures.  This variable tracks
      // array indirections so they can be percolated from outer structs to inner variables.
      std::vector <int> arrayElement;
  
      TStorageQualifier leftStorage = left->getType().getQualifier().storage;
      TStorageQualifier rightStorage = right->getType().getQualifier().storage;
  
      int leftOffset = findSubtreeOffset(*left);
      int rightOffset = findSubtreeOffset(*right);
  
      const auto getMember = [&](bool isLeft, const TType& type, int member, TIntermTyped* splitNode, int splitMember,
                                 bool flattened)
                             -> TIntermTyped * {
          const bool split     = isLeft ? isSplitLeft   : isSplitRight;
  
          TIntermTyped* subTree;
          const TType derefType(type, member);
          const TVariable* builtInVar = nullptr;
          if ((flattened || split) && derefType.isBuiltIn()) {
              auto splitPair = splitBuiltIns.find(HlslParseContext::tInterstageIoData(
                                                     derefType.getQualifier().builtIn,
                                                     isLeft ? leftStorage : rightStorage));
              if (splitPair != splitBuiltIns.end())
                  builtInVar = splitPair->second;
          }
          if (builtInVar != nullptr) {
              // copy from interstage IO built-in if needed
              subTree = intermediate.addSymbol(*builtInVar);
  
              if (subTree->getType().isArray()) {
                  // Arrayness of builtIn symbols isn't handled by the normal recursion:
                  // it's been extracted and moved to the built-in.
                  if (!arrayElement.empty()) {
                      const TType splitDerefType(subTree->getType(), arrayElement.back());
                      subTree = intermediate.addIndex(EOpIndexDirect, subTree,
                                                      intermediate.addConstantUnion(arrayElement.back(), loc), loc);
                      subTree->setType(splitDerefType);
                  } else if (splitNode->getAsOperator() != nullptr && (splitNode->getAsOperator()->getOp() == EOpIndexIndirect)) {
                      // This might also be a stage with arrayed outputs, in which case there's an index
                      // operation we should transfer to the output builtin.
  
                      const TType splitDerefType(subTree->getType(), 0);
                      subTree = intermediate.addIndex(splitNode->getAsOperator()->getOp(), subTree,
                                                      splitNode->getAsBinaryNode()->getRight(), loc);
                      subTree->setType(splitDerefType);
                  }
              }
          } else if (flattened && !shouldFlatten(derefType, isLeft ? leftStorage : rightStorage, false)) {
              if (isLeft)
                  subTree = intermediate.addSymbol(*(*leftVariables)[leftOffset++]);
              else
                  subTree = intermediate.addSymbol(*(*rightVariables)[rightOffset++]);
          } else {
              // Index operator if it's an aggregate, else EOpNull
              const TOperator accessOp = type.isArray()  ? EOpIndexDirect
                                       : type.isStruct() ? EOpIndexDirectStruct
                                       : EOpNull;
              if (accessOp == EOpNull) {
                  subTree = splitNode;
              } else {
                  subTree = intermediate.addIndex(accessOp, splitNode, intermediate.addConstantUnion(splitMember, loc),
                                                  loc);
                  const TType splitDerefType(splitNode->getType(), splitMember);
                  subTree->setType(splitDerefType);
              }
          }
  
          return subTree;
      };
  
      // Use the proper RHS node: a new symbol from a TVariable, copy
      // of an TIntermSymbol node, or sometimes the right node directly.
      right = rhsTempVar != nullptr   ? intermediate.addSymbol(*rhsTempVar, loc) :
              cloneSymNode != nullptr ? intermediate.addSymbol(*cloneSymNode) :
              right;
  
      // Cannot use auto here, because this is recursive, and auto can't work out the type without seeing the
      // whole thing.  So, we'll resort to an explicit type via std::function.
      const std::function<void(TIntermTyped* left, TIntermTyped* right, TIntermTyped* splitLeft, TIntermTyped* splitRight,
                               bool topLevel)>
      traverse = [&](TIntermTyped* left, TIntermTyped* right, TIntermTyped* splitLeft, TIntermTyped* splitRight,
                     bool topLevel) -> void {
          // If we get here, we are assigning to or from a whole array or struct that must be
          // flattened, so have to do member-by-member assignment:
  
          bool shouldFlattenSubsetLeft = isFlattenLeft && shouldFlatten(left->getType(), leftStorage, topLevel);
          bool shouldFlattenSubsetRight = isFlattenRight && shouldFlatten(right->getType(), rightStorage, topLevel);
  
          if ((left->getType().isArray() || right->getType().isArray()) &&
                (shouldFlattenSubsetLeft  || isSplitLeft ||
                 shouldFlattenSubsetRight || isSplitRight)) {
              const int elementsL = left->getType().isArray()  ? left->getType().getOuterArraySize()  : 1;
              const int elementsR = right->getType().isArray() ? right->getType().getOuterArraySize() : 1;
  
              // The arrays might not be the same size,
              // e.g., if the size has been forced for EbvTessLevelInner/Outer.
              const int elementsToCopy = std::min(elementsL, elementsR);
  
              // array case
              for (int element = 0; element < elementsToCopy; ++element) {
                  arrayElement.push_back(element);
  
                  // Add a new AST symbol node if we have a temp variable holding a complex RHS.
                  TIntermTyped* subLeft  = getMember(true,  left->getType(),  element, left, element,
                                                     shouldFlattenSubsetLeft);
                  TIntermTyped* subRight = getMember(false, right->getType(), element, right, element,
                                                     shouldFlattenSubsetRight);
  
                  TIntermTyped* subSplitLeft =  isSplitLeft  ? getMember(true,  left->getType(),  element, splitLeft,
                                                                         element, shouldFlattenSubsetLeft)
                                                             : subLeft;
                  TIntermTyped* subSplitRight = isSplitRight ? getMember(false, right->getType(), element, splitRight,
                                                                         element, shouldFlattenSubsetRight)
                                                             : subRight;
  
                  traverse(subLeft, subRight, subSplitLeft, subSplitRight, false);
  
                  arrayElement.pop_back();
              }
          } else if (left->getType().isStruct() && (shouldFlattenSubsetLeft  || isSplitLeft ||
                                                    shouldFlattenSubsetRight || isSplitRight)) {
              // struct case
              const auto& membersL = *left->getType().getStruct();
              const auto& membersR = *right->getType().getStruct();
  
              // These track the members in the split structures corresponding to the same in the unsplit structures,
              // which we traverse in parallel.
              int memberL = 0;
              int memberR = 0;
  
              // Handle empty structure assignment
              if (int(membersL.size()) == 0 && int(membersR.size()) == 0)
                  assignList = intermediate.growAggregate(assignList, intermediate.addAssign(op, left, right, loc), loc);
  
              for (int member = 0; member < int(membersL.size()); ++member) {
                  const TType& typeL = *membersL[member].type;
                  const TType& typeR = *membersR[member].type;
  
                  TIntermTyped* subLeft  = getMember(true,  left->getType(), member, left, member,
                                                     shouldFlattenSubsetLeft);
                  TIntermTyped* subRight = getMember(false, right->getType(), member, right, member,
                                                     shouldFlattenSubsetRight);
  
                  // If there is no splitting, use the same values to avoid inefficiency.
                  TIntermTyped* subSplitLeft =  isSplitLeft  ? getMember(true,  left->getType(),  member, splitLeft,
                                                                         memberL, shouldFlattenSubsetLeft)
                                                             : subLeft;
                  TIntermTyped* subSplitRight = isSplitRight ? getMember(false, right->getType(), member, splitRight,
                                                                         memberR, shouldFlattenSubsetRight)
                                                             : subRight;
  
                  if (isClipOrCullDistance(subSplitLeft->getType()) || isClipOrCullDistance(subSplitRight->getType())) {
                      // Clip and cull distance built-in assignment is complex in its own right, and is handled in
                      // a separate function dedicated to that task.  See comment above assignClipCullDistance;
  
                      const bool isOutput = isClipOrCullDistance(subSplitLeft->getType());
  
                      // Since all clip/cull semantics boil down to the same built-in type, we need to get the
                      // semantic ID from the dereferenced type's layout location, to avoid an N-1 mapping.
                      const TType derefType((isOutput ? left : right)->getType(), member);
                      const int semanticId = derefType.getQualifier().layoutLocation;
  
                      TIntermAggregate* clipCullAssign = assignClipCullDistance(loc, op, semanticId,
                                                                                subSplitLeft, subSplitRight);
  
                      assignList = intermediate.growAggregate(assignList, clipCullAssign, loc);
                  } else if (assignsClipPos(subSplitLeft)) {
                      // Position can require special handling: see comment above assignPosition
                      TIntermTyped* positionAssign = assignPosition(loc, op, subSplitLeft, subSplitRight);
                      assignList = intermediate.growAggregate(assignList, positionAssign, loc);
                  } else if (!shouldFlattenSubsetLeft && !shouldFlattenSubsetRight &&
                             !typeL.containsBuiltIn() && !typeR.containsBuiltIn()) {
                      // If this is the final flattening (no nested types below to flatten)
                      // we'll copy the member, else recurse into the type hierarchy.
                      // However, if splitting the struct, that means we can copy a whole
                      // subtree here IFF it does not itself contain any interstage built-in
                      // IO variables, so we only have to recurse into it if there's something
                      // for splitting to do.  That can save a lot of AST verbosity for
                      // a bunch of memberwise copies.
  
                      assignList = intermediate.growAggregate(assignList,
                                                              intermediate.addAssign(op, subSplitLeft, subSplitRight, loc),
                                                              loc);
                  } else {
                      traverse(subLeft, subRight, subSplitLeft, subSplitRight, false);
                  }
  
                  memberL += (typeL.isBuiltIn() ? 0 : 1);
                  memberR += (typeR.isBuiltIn() ? 0 : 1);
              }
          } else {
              // Member copy
              assignList = intermediate.growAggregate(assignList, intermediate.addAssign(op, left, right, loc), loc);
          }
  
      };
  
      TIntermTyped* splitLeft  = left;
      TIntermTyped* splitRight = right;
  
      // If either left or right was a split structure, we must read or write it, but still have to
      // parallel-recurse through the unsplit structure to identify the built-in IO vars.
      // The left can be either a symbol, or an index into a symbol (e.g, array reference)
      if (isSplitLeft) {
          if (indexesSplit(left)) {
              // Index case: Refer to the indexed symbol, if the left is an index operator.
              const TIntermSymbol* symNode = left->getAsBinaryNode()->getLeft()->getAsSymbolNode();
  
              TIntermTyped* splitLeftNonIo = intermediate.addSymbol(*getSplitNonIoVar(symNode->getId()), loc);
  
              splitLeft = intermediate.addIndex(left->getAsBinaryNode()->getOp(), splitLeftNonIo,
                                                left->getAsBinaryNode()->getRight(), loc);
  
              const TType derefType(splitLeftNonIo->getType(), 0);
              splitLeft->setType(derefType);
          } else {
              // Symbol case: otherwise, if not indexed, we have the symbol directly.
              const TIntermSymbol* symNode = left->getAsSymbolNode();
              splitLeft = intermediate.addSymbol(*getSplitNonIoVar(symNode->getId()), loc);
          }
      }
  
      if (isSplitRight)
          splitRight = intermediate.addSymbol(*getSplitNonIoVar(right->getAsSymbolNode()->getId()), loc);
  
      // This makes the whole assignment, recursing through subtypes as needed.
      traverse(left, right, splitLeft, splitRight, true);
  
      assert(assignList != nullptr);
      assignList->setOperator(EOpSequence);
  
      return assignList;
  }
  
  // An assignment to matrix swizzle must be decomposed into individual assignments.
  // These must be selected component-wise from the RHS and stored component-wise
  // into the LHS.
  TIntermTyped* HlslParseContext::handleAssignToMatrixSwizzle(const TSourceLoc& loc, TOperator op, TIntermTyped* left,
                                                              TIntermTyped* right)
  {
      assert(left->getAsOperator() && left->getAsOperator()->getOp() == EOpMatrixSwizzle);
  
      if (op != EOpAssign)
          error(loc, "only simple assignment to non-simple matrix swizzle is supported", "assign", "");
  
      // isolate the matrix and swizzle nodes
      TIntermTyped* matrix = left->getAsBinaryNode()->getLeft()->getAsTyped();
      const TIntermSequence& swizzle = left->getAsBinaryNode()->getRight()->getAsAggregate()->getSequence();
  
      // if the RHS isn't already a simple vector, let's store into one
      TIntermSymbol* vector = right->getAsSymbolNode();
      TIntermTyped* vectorAssign = nullptr;
      if (vector == nullptr) {
          // create a new intermediate vector variable to assign to
          TType vectorType(matrix->getBasicType(), EvqTemporary, matrix->getQualifier().precision, (int)swizzle.size()/2);
          vector = intermediate.addSymbol(*makeInternalVariable("intermVec", vectorType), loc);
  
          // assign the right to the new vector
          vectorAssign = handleAssign(loc, op, vector, right);
      }
  
      // Assign the vector components to the matrix components.
      // Store this as a sequence, so a single aggregate node represents this
      // entire operation.
      TIntermAggregate* result = intermediate.makeAggregate(vectorAssign);
      TType columnType(matrix->getType(), 0);
      TType componentType(columnType, 0);
      TType indexType(EbtInt);
      for (int i = 0; i < (int)swizzle.size(); i += 2) {
          // the right component, single index into the RHS vector
          TIntermTyped* rightComp = intermediate.addIndex(EOpIndexDirect, vector,
                                      intermediate.addConstantUnion(i/2, loc), loc);
  
          // the left component, double index into the LHS matrix
          TIntermTyped* leftComp = intermediate.addIndex(EOpIndexDirect, matrix,
                                      intermediate.addConstantUnion(swizzle[i]->getAsConstantUnion()->getConstArray(),
                                                                    indexType, loc),
                                      loc);
          leftComp->setType(columnType);
          leftComp = intermediate.addIndex(EOpIndexDirect, leftComp,
                                      intermediate.addConstantUnion(swizzle[i+1]->getAsConstantUnion()->getConstArray(),
                                                                    indexType, loc),
                                      loc);
          leftComp->setType(componentType);
  
          // Add the assignment to the aggregate
          result = intermediate.growAggregate(result, intermediate.addAssign(op, leftComp, rightComp, loc));
      }
  
      result->setOp(EOpSequence);
  
      return result;
  }
  
  //
  // HLSL atomic operations have slightly different arguments than
  // GLSL/AST/SPIRV.  The semantics are converted below in decomposeIntrinsic.
  // This provides the post-decomposition equivalent opcode.
  //
  TOperator HlslParseContext::mapAtomicOp(const TSourceLoc& loc, TOperator op, bool isImage)
  {
      switch (op) {
      case EOpInterlockedAdd:             return isImage ? EOpImageAtomicAdd      : EOpAtomicAdd;
      case EOpInterlockedAnd:             return isImage ? EOpImageAtomicAnd      : EOpAtomicAnd;
      case EOpInterlockedCompareExchange: return isImage ? EOpImageAtomicCompSwap : EOpAtomicCompSwap;
      case EOpInterlockedMax:             return isImage ? EOpImageAtomicMax      : EOpAtomicMax;
      case EOpInterlockedMin:             return isImage ? EOpImageAtomicMin      : EOpAtomicMin;
      case EOpInterlockedOr:              return isImage ? EOpImageAtomicOr       : EOpAtomicOr;
      case EOpInterlockedXor:             return isImage ? EOpImageAtomicXor      : EOpAtomicXor;
      case EOpInterlockedExchange:        return isImage ? EOpImageAtomicExchange : EOpAtomicExchange;
      case EOpInterlockedCompareStore:  // TODO: ...
      default:
          error(loc, "unknown atomic operation", "unknown op", "");
          return EOpNull;
      }
  }
  
  //
  // Create a combined sampler/texture from separate sampler and texture.
  //
  TIntermAggregate* HlslParseContext::handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex,
                                                                  TIntermTyped* argSampler)
  {
      TIntermAggregate* txcombine = new TIntermAggregate(EOpConstructTextureSampler);
  
      txcombine->getSequence().push_back(argTex);
      txcombine->getSequence().push_back(argSampler);
  
      TSampler samplerType = argTex->getType().getSampler();
      samplerType.combined = true;
  
      // TODO:
      // This block exists until the spec no longer requires shadow modes on texture objects.
      // It can be deleted after that, along with the shadowTextureVariant member.
      {
          const bool shadowMode = argSampler->getType().getSampler().shadow;
  
          TIntermSymbol* texSymbol = argTex->getAsSymbolNode();
  
          if (texSymbol == nullptr)
              texSymbol = argTex->getAsBinaryNode()->getLeft()->getAsSymbolNode();
  
          if (texSymbol == nullptr) {
              error(loc, "unable to find texture symbol", "", "");
              return nullptr;
          }
  
          // This forces the texture's shadow state to be the sampler's
          // shadow state.  This depends on downstream optimization to
          // DCE one variant in [shadow, nonshadow] if both are present,
          // or the SPIR-V module would be invalid.
          int newId = texSymbol->getId();
  
          // Check to see if this texture has been given a shadow mode already.
          // If so, look up the one we already have.
          const auto textureShadowEntry = textureShadowVariant.find(texSymbol->getId());
  
          if (textureShadowEntry != textureShadowVariant.end())
              newId = textureShadowEntry->second->get(shadowMode);
          else
              textureShadowVariant[texSymbol->getId()] = NewPoolObject(tShadowTextureSymbols(), 1);
  
          // Sometimes we have to create another symbol (if this texture has been seen before,
          // and we haven't created the form for this shadow mode).
          if (newId == -1) {
              TType texType;
              texType.shallowCopy(argTex->getType());
              texType.getSampler().shadow = shadowMode;  // set appropriate shadow mode.
              globalQualifierFix(loc, texType.getQualifier());
  
              TVariable* newTexture = makeInternalVariable(texSymbol->getName(), texType);
  
              trackLinkage(*newTexture);
  
              newId = newTexture->getUniqueId();
          }
  
          assert(newId != -1);
  
          if (textureShadowVariant.find(newId) == textureShadowVariant.end())
              textureShadowVariant[newId] = textureShadowVariant[texSymbol->getId()];
  
          textureShadowVariant[newId]->set(shadowMode, newId);
  
          // Remember this shadow mode in the texture and the merged type.
          argTex->getWritableType().getSampler().shadow = shadowMode;
          samplerType.shadow = shadowMode;
  
          texSymbol->switchId(newId);
      }
  
      txcombine->setType(TType(samplerType, EvqTemporary));
      txcombine->setLoc(loc);
  
      return txcombine;
  }
  
  // Return true if this a buffer type that has an associated counter buffer.
  bool HlslParseContext::hasStructBuffCounter(const TType& type) const
  {
      switch (type.getQualifier().declaredBuiltIn) {
      case EbvAppendConsume:       // fall through...
      case EbvRWStructuredBuffer:  // ...
          return true;
      default:
          return false; // the other structuredbuffer types do not have a counter.
      }
  }
  
  void HlslParseContext::counterBufferType(const TSourceLoc& loc, TType& type)
  {
      // Counter type
      TType* counterType = new TType(EbtUint, EvqBuffer);
      counterType->setFieldName(intermediate.implicitCounterName);
  
      TTypeList* blockStruct = new TTypeList;
      TTypeLoc  member = { counterType, loc };
      blockStruct->push_back(member);
  
      TType blockType(blockStruct, "", counterType->getQualifier());
      blockType.getQualifier().storage = EvqBuffer;
  
      type.shallowCopy(blockType);
      shareStructBufferType(type);
  }
  
  // declare counter for a structured buffer type
  void HlslParseContext::declareStructBufferCounter(const TSourceLoc& loc, const TType& bufferType, const TString& name)
  {
      // Bail out if not a struct buffer
      if (! isStructBufferType(bufferType))
          return;
  
      if (! hasStructBuffCounter(bufferType))
          return;
  
      TType blockType;
      counterBufferType(loc, blockType);
  
      TString* blockName = NewPoolTString(intermediate.addCounterBufferName(name).c_str());
  
      // Counter buffer is not yet in use
      structBufferCounter[*blockName] = false;
  
      shareStructBufferType(blockType);
      declareBlock(loc, blockType, blockName);
  }
  
  // return the counter that goes with a given structuredbuffer
  TIntermTyped* HlslParseContext::getStructBufferCounter(const TSourceLoc& loc, TIntermTyped* buffer)
  {
      // Bail out if not a struct buffer
      if (buffer == nullptr || ! isStructBufferType(buffer->getType()))
          return nullptr;
  
      const TString counterBlockName(intermediate.addCounterBufferName(buffer->getAsSymbolNode()->getName()));
  
      // Mark the counter as being used
      structBufferCounter[counterBlockName] = true;
  
      TIntermTyped* counterVar = handleVariable(loc, &counterBlockName);  // find the block structure
      TIntermTyped* index = intermediate.addConstantUnion(0, loc); // index to counter inside block struct
  
      TIntermTyped* counterMember = intermediate.addIndex(EOpIndexDirectStruct, counterVar, index, loc);
      counterMember->setType(TType(EbtUint));
      return counterMember;
  }
  
  //
  // Decompose structure buffer methods into AST
  //
  void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TIntermTyped*& node, TIntermNode* arguments)
  {
      if (node == nullptr || node->getAsOperator() == nullptr || arguments == nullptr)
          return;
  
      const TOperator op  = node->getAsOperator()->getOp();
      TIntermAggregate* argAggregate = arguments->getAsAggregate();
  
      // Buffer is the object upon which method is called, so always arg 0
      TIntermTyped* bufferObj = nullptr;
  
      // The parameters can be an aggregate, or just a the object as a symbol if there are no fn params.
      if (argAggregate) {
          if (argAggregate->getSequence().empty())
              return;
          if (argAggregate->getSequence()[0])
              bufferObj = argAggregate->getSequence()[0]->getAsTyped();
      } else {
          bufferObj = arguments->getAsSymbolNode();
      }
  
      if (bufferObj == nullptr || bufferObj->getAsSymbolNode() == nullptr)
          return;
  
      // Some methods require a hidden internal counter, obtained via getStructBufferCounter().
      // This lambda adds something to it and returns the old value.
      const auto incDecCounter = [&](int incval) -> TIntermTyped* {
          TIntermTyped* incrementValue = intermediate.addConstantUnion(static_cast<unsigned int>(incval), loc, true);
          TIntermTyped* counter = getStructBufferCounter(loc, bufferObj); // obtain the counter member
  
          if (counter == nullptr)
              return nullptr;
  
          TIntermAggregate* counterIncrement = new TIntermAggregate(EOpAtomicAdd);
          counterIncrement->setType(TType(EbtUint, EvqTemporary));
          counterIncrement->setLoc(loc);
          counterIncrement->getSequence().push_back(counter);
          counterIncrement->getSequence().push_back(incrementValue);
  
          return counterIncrement;
      };
  
      // Index to obtain the runtime sized array out of the buffer.
      TIntermTyped* argArray = indexStructBufferContent(loc, bufferObj);
      if (argArray == nullptr)
          return;  // It might not be a struct buffer method.
  
      switch (op) {
      case EOpMethodLoad:
          {
              TIntermTyped* argIndex = makeIntegerIndex(argAggregate->getSequence()[1]->getAsTyped());  // index
  
              const TType& bufferType = bufferObj->getType();
  
              const TBuiltInVariable builtInType = bufferType.getQualifier().declaredBuiltIn;
  
              // Byte address buffers index in bytes (only multiples of 4 permitted... not so much a byte address
              // buffer then, but that's what it calls itself.
              const bool isByteAddressBuffer = (builtInType == EbvByteAddressBuffer   || 
                                                builtInType == EbvRWByteAddressBuffer);
                  
  
              if (isByteAddressBuffer)
                  argIndex = intermediate.addBinaryNode(EOpRightShift, argIndex,
                                                        intermediate.addConstantUnion(2, loc, true),
                                                        loc, TType(EbtInt));
  
              // Index into the array to find the item being loaded.
              const TOperator idxOp = (argIndex->getQualifier().storage == EvqConst) ? EOpIndexDirect : EOpIndexIndirect;
  
              node = intermediate.addIndex(idxOp, argArray, argIndex, loc);
  
              const TType derefType(argArray->getType(), 0);
              node->setType(derefType);
          }
          
          break;
  
      case EOpMethodLoad2:
      case EOpMethodLoad3:
      case EOpMethodLoad4:
          {
              TIntermTyped* argIndex = makeIntegerIndex(argAggregate->getSequence()[1]->getAsTyped());  // index
  
              TOperator constructOp = EOpNull;
              int size = 0;
  
              switch (op) {
              case EOpMethodLoad2: size = 2; constructOp = EOpConstructVec2; break;
              case EOpMethodLoad3: size = 3; constructOp = EOpConstructVec3; break;
              case EOpMethodLoad4: size = 4; constructOp = EOpConstructVec4; break;
              default: assert(0);
              }
  
              TIntermTyped* body = nullptr;
  
              // First, we'll store the address in a variable to avoid multiple shifts
              // (we must convert the byte address to an item address)
              TIntermTyped* byteAddrIdx = intermediate.addBinaryNode(EOpRightShift, argIndex,
                                                                     intermediate.addConstantUnion(2, loc, true),
                                                                     loc, TType(EbtInt));
  
              TVariable* byteAddrSym = makeInternalVariable("byteAddrTemp", TType(EbtInt, EvqTemporary));
              TIntermTyped* byteAddrIdxVar = intermediate.addSymbol(*byteAddrSym, loc);
  
              body = intermediate.growAggregate(body, intermediate.addAssign(EOpAssign, byteAddrIdxVar, byteAddrIdx, loc));
  
              TIntermTyped* vec = nullptr;
  
              // These are only valid on (rw)byteaddressbuffers, so we can always perform the >>2
              // address conversion.
              for (int idx=0; idx<size; ++idx) {
                  TIntermTyped* offsetIdx = byteAddrIdxVar;
  
                  // add index offset
                  if (idx != 0)
                      offsetIdx = intermediate.addBinaryNode(EOpAdd, offsetIdx,
                                                             intermediate.addConstantUnion(idx, loc, true),
                                                             loc, TType(EbtInt));
  
                  const TOperator idxOp = (offsetIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect
                                                                                          : EOpIndexIndirect;
  
                  TIntermTyped* indexVal = intermediate.addIndex(idxOp, argArray, offsetIdx, loc);
  
                  TType derefType(argArray->getType(), 0);
                  derefType.getQualifier().makeTemporary();
                  indexVal->setType(derefType);
  
                  vec = intermediate.growAggregate(vec, indexVal);
              }
  
              vec->setType(TType(argArray->getBasicType(), EvqTemporary, size));
              vec->getAsAggregate()->setOperator(constructOp);
  
              body = intermediate.growAggregate(body, vec);
              body->setType(vec->getType());
              body->getAsAggregate()->setOperator(EOpSequence);
  
              node = body;
          }
  
          break;
  
      case EOpMethodStore:
      case EOpMethodStore2:
      case EOpMethodStore3:
      case EOpMethodStore4:
          {
              TIntermTyped* argIndex = makeIntegerIndex(argAggregate->getSequence()[1]->getAsTyped());  // index
              TIntermTyped* argValue = argAggregate->getSequence()[2]->getAsTyped();  // value
  
              // Index into the array to find the item being loaded.
              // Byte address buffers index in bytes (only multiples of 4 permitted... not so much a byte address
              // buffer then, but that's what it calls itself).
  
              int size = 0;
  
              switch (op) {
              case EOpMethodStore:  size = 1; break;
              case EOpMethodStore2: size = 2; break;
              case EOpMethodStore3: size = 3; break;
              case EOpMethodStore4: size = 4; break;
              default: assert(0);
              }
  
              TIntermAggregate* body = nullptr;
  
              // First, we'll store the address in a variable to avoid multiple shifts
              // (we must convert the byte address to an item address)
              TIntermTyped* byteAddrIdx = intermediate.addBinaryNode(EOpRightShift, argIndex,
                                                                     intermediate.addConstantUnion(2, loc, true), loc, TType(EbtInt));
  
              TVariable* byteAddrSym = makeInternalVariable("byteAddrTemp", TType(EbtInt, EvqTemporary));
              TIntermTyped* byteAddrIdxVar = intermediate.addSymbol(*byteAddrSym, loc);
  
              body = intermediate.growAggregate(body, intermediate.addAssign(EOpAssign, byteAddrIdxVar, byteAddrIdx, loc));
  
              for (int idx=0; idx<size; ++idx) {
                  TIntermTyped* offsetIdx = byteAddrIdxVar;
                  TIntermTyped* idxConst = intermediate.addConstantUnion(idx, loc, true);
  
                  // add index offset
                  if (idx != 0)
                      offsetIdx = intermediate.addBinaryNode(EOpAdd, offsetIdx, idxConst, loc, TType(EbtInt));
  
                  const TOperator idxOp = (offsetIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect
                                                                                          : EOpIndexIndirect;
  
                  TIntermTyped* lValue = intermediate.addIndex(idxOp, argArray, offsetIdx, loc);
                  const TType derefType(argArray->getType(), 0);
                  lValue->setType(derefType);
  
                  TIntermTyped* rValue;
                  if (size == 1) {
                      rValue = argValue;
                  } else {
                      rValue = intermediate.addIndex(EOpIndexDirect, argValue, idxConst, loc);
                      const TType indexType(argValue->getType(), 0);
                      rValue->setType(indexType);
                  }
                      
                  TIntermTyped* assign = intermediate.addAssign(EOpAssign, lValue, rValue, loc); 
  
                  body = intermediate.growAggregate(body, assign);
              }
  
              body->setOperator(EOpSequence);
              node = body;
          }
  
          break;
  
      case EOpMethodGetDimensions:
          {
              const int numArgs = (int)argAggregate->getSequence().size();
              TIntermTyped* argNumItems = argAggregate->getSequence()[1]->getAsTyped();  // out num items
              TIntermTyped* argStride   = numArgs > 2 ? argAggregate->getSequence()[2]->getAsTyped() : nullptr;  // out stride
  
              TIntermAggregate* body = nullptr;
  
              // Length output:
              if (argArray->getType().isSizedArray()) {
                  const int length = argArray->getType().getOuterArraySize();
                  TIntermTyped* assign = intermediate.addAssign(EOpAssign, argNumItems,
                                                                intermediate.addConstantUnion(length, loc, true), loc);
                  body = intermediate.growAggregate(body, assign, loc);
              } else {
                  TIntermTyped* lengthCall = intermediate.addBuiltInFunctionCall(loc, EOpArrayLength, true, argArray,
                                                                                 argNumItems->getType());
                  TIntermTyped* assign = intermediate.addAssign(EOpAssign, argNumItems, lengthCall, loc);
                  body = intermediate.growAggregate(body, assign, loc);
              }
  
              // Stride output:
              if (argStride != nullptr) {
                  int size;
                  int stride;
                  intermediate.getMemberAlignment(argArray->getType(), size, stride, argArray->getType().getQualifier().layoutPacking,
                                                  argArray->getType().getQualifier().layoutMatrix == ElmRowMajor);
  
                  TIntermTyped* assign = intermediate.addAssign(EOpAssign, argStride,
                                                                intermediate.addConstantUnion(stride, loc, true), loc);
  
                  body = intermediate.growAggregate(body, assign);
              }
  
              body->setOperator(EOpSequence);
              node = body;
          }
  
          break;
  
      case EOpInterlockedAdd:
      case EOpInterlockedAnd:
      case EOpInterlockedExchange:
      case EOpInterlockedMax:
      case EOpInterlockedMin:
      case EOpInterlockedOr:
      case EOpInterlockedXor:
      case EOpInterlockedCompareExchange:
      case EOpInterlockedCompareStore:
          {
              // We'll replace the first argument with the block dereference, and let
              // downstream decomposition handle the rest.
  
              TIntermSequence& sequence = argAggregate->getSequence();
  
              TIntermTyped* argIndex     = makeIntegerIndex(sequence[1]->getAsTyped());  // index
              argIndex = intermediate.addBinaryNode(EOpRightShift, argIndex, intermediate.addConstantUnion(2, loc, true),
                                                    loc, TType(EbtInt));
  
              const TOperator idxOp = (argIndex->getQualifier().storage == EvqConst) ? EOpIndexDirect : EOpIndexIndirect;
              TIntermTyped* element = intermediate.addIndex(idxOp, argArray, argIndex, loc);
  
              const TType derefType(argArray->getType(), 0);
              element->setType(derefType);
  
              // Replace the numeric byte offset parameter with array reference.
              sequence[1] = element;
              sequence.erase(sequence.begin(), sequence.begin()+1);
          }
          break;
  
      case EOpMethodIncrementCounter:
          {
              node = incDecCounter(1);
              break;
          }
  
      case EOpMethodDecrementCounter:
          {
              TIntermTyped* preIncValue = incDecCounter(-1); // result is original value
              node = intermediate.addBinaryNode(EOpAdd, preIncValue, intermediate.addConstantUnion(-1, loc, true), loc,
                                                preIncValue->getType());
              break;
          }
  
      case EOpMethodAppend:
          {
              TIntermTyped* oldCounter = incDecCounter(1);
  
              TIntermTyped* lValue = intermediate.addIndex(EOpIndexIndirect, argArray, oldCounter, loc);
              TIntermTyped* rValue = argAggregate->getSequence()[1]->getAsTyped();
  
              const TType derefType(argArray->getType(), 0);
              lValue->setType(derefType);
  
              node = intermediate.addAssign(EOpAssign, lValue, rValue, loc);
  
              break;
          }
  
      case EOpMethodConsume:
          {
              TIntermTyped* oldCounter = incDecCounter(-1);
  
              TIntermTyped* newCounter = intermediate.addBinaryNode(EOpAdd, oldCounter,
                                                                    intermediate.addConstantUnion(-1, loc, true), loc,
                                                                    oldCounter->getType());
  
              node = intermediate.addIndex(EOpIndexIndirect, argArray, newCounter, loc);
  
              const TType derefType(argArray->getType(), 0);
              node->setType(derefType);
  
              break;
          }
  
      default:
          break; // most pass through unchanged
      }
  }
  
  // Create array of standard sample positions for given sample count.
  // TODO: remove when a real method to query sample pos exists in SPIR-V.
  TIntermConstantUnion* HlslParseContext::getSamplePosArray(int count)
  {
      struct tSamplePos { float x, y; };
  
      static const tSamplePos pos1[] = {
          { 0.0/16.0,  0.0/16.0 },
      };
  
      // standard sample positions for 2, 4, 8, and 16 samples.
      static const tSamplePos pos2[] = {
          { 4.0/16.0,  4.0/16.0 }, {-4.0/16.0, -4.0/16.0 },
      };
  
      static const tSamplePos pos4[] = {
          {-2.0/16.0, -6.0/16.0 }, { 6.0/16.0, -2.0/16.0 }, {-6.0/16.0,  2.0/16.0 }, { 2.0/16.0,  6.0/16.0 },
      };
  
      static const tSamplePos pos8[] = {
          { 1.0/16.0, -3.0/16.0 }, {-1.0/16.0,  3.0/16.0 }, { 5.0/16.0,  1.0/16.0 }, {-3.0/16.0, -5.0/16.0 },
          {-5.0/16.0,  5.0/16.0 }, {-7.0/16.0, -1.0/16.0 }, { 3.0/16.0,  7.0/16.0 }, { 7.0/16.0, -7.0/16.0 },
      };
  
      static const tSamplePos pos16[] = {
          { 1.0/16.0,  1.0/16.0 }, {-1.0/16.0, -3.0/16.0 }, {-3.0/16.0,  2.0/16.0 }, { 4.0/16.0, -1.0/16.0 },
          {-5.0/16.0, -2.0/16.0 }, { 2.0/16.0,  5.0/16.0 }, { 5.0/16.0,  3.0/16.0 }, { 3.0/16.0, -5.0/16.0 },
          {-2.0/16.0,  6.0/16.0 }, { 0.0/16.0, -7.0/16.0 }, {-4.0/16.0, -6.0/16.0 }, {-6.0/16.0,  4.0/16.0 },
          {-8.0/16.0,  0.0/16.0 }, { 7.0/16.0, -4.0/16.0 }, { 6.0/16.0,  7.0/16.0 }, {-7.0/16.0, -8.0/16.0 },
      };
  
      const tSamplePos* sampleLoc = nullptr;
      int numSamples = count;
  
      switch (count) {
      case 2:  sampleLoc = pos2;  break;
      case 4:  sampleLoc = pos4;  break;
      case 8:  sampleLoc = pos8;  break;
      case 16: sampleLoc = pos16; break;
      default:
          sampleLoc = pos1;
          numSamples = 1;
      }
  
      TConstUnionArray* values = new TConstUnionArray(numSamples*2);
      
      for (int pos=0; pos<count; ++pos) {
          TConstUnion x, y;
          x.setDConst(sampleLoc[pos].x);
          y.setDConst(sampleLoc[pos].y);
  
          (*values)[pos*2+0] = x;
          (*values)[pos*2+1] = y;
      }
  
      TType retType(EbtFloat, EvqConst, 2);
  
      if (numSamples != 1) {
          TArraySizes* arraySizes = new TArraySizes;
          arraySizes->addInnerSize(numSamples);
          retType.transferArraySizes(arraySizes);
      }
  
      return new TIntermConstantUnion(*values, retType);
  }
  
  //
  // Decompose DX9 and DX10 sample intrinsics & object methods into AST
  //
  void HlslParseContext::decomposeSampleMethods(const TSourceLoc& loc, TIntermTyped*& node, TIntermNode* arguments)
  {
      if (node == nullptr || !node->getAsOperator())
          return;
  
      // Sampler return must always be a vec4, but we can construct a shorter vector or a structure from it.
      const auto convertReturn = [&loc, &node, this](TIntermTyped* result, const TSampler& sampler) -> TIntermTyped* {
          result->setType(TType(node->getType().getBasicType(), EvqTemporary, node->getVectorSize()));
  
          TIntermTyped* convertedResult = nullptr;
          
          TType retType;
          getTextureReturnType(sampler, retType);
  
          if (retType.isStruct()) {
              // For type convenience, conversionAggregate points to the convertedResult (we know it's an aggregate here)
              TIntermAggregate* conversionAggregate = new TIntermAggregate;
              convertedResult = conversionAggregate;
  
              // Convert vector output to return structure.  We will need a temp symbol to copy the results to.
              TVariable* structVar = makeInternalVariable("@sampleStructTemp", retType);
  
              // We also need a temp symbol to hold the result of the texture.  We don't want to re-fetch the
              // sample each time we'll index into the result, so we'll copy to this, and index into the copy.
              TVariable* sampleShadow = makeInternalVariable("@sampleResultShadow", result->getType());
  
              // Initial copy from texture to our sample result shadow.
              TIntermTyped* shadowCopy = intermediate.addAssign(EOpAssign, intermediate.addSymbol(*sampleShadow, loc),
                                                                result, loc);
  
              conversionAggregate->getSequence().push_back(shadowCopy);
  
              unsigned vec4Pos = 0;
  
              for (unsigned m = 0; m < unsigned(retType.getStruct()->size()); ++m) {
                  const TType memberType(retType, m); // dereferenced type of the member we're about to assign.
                  
                  // Check for bad struct members.  This should have been caught upstream.  Complain, because
                  // wwe don't know what to do with it.  This algorithm could be generalized to handle
                  // other things, e.g, sub-structures, but HLSL doesn't allow them.
                  if (!memberType.isVector() && !memberType.isScalar()) {
                      error(loc, "expected: scalar or vector type in texture structure", "", "");
                      return nullptr;
                  }
                      
                  // Index into the struct variable to find the member to assign.
                  TIntermTyped* structMember = intermediate.addIndex(EOpIndexDirectStruct,
                                                                     intermediate.addSymbol(*structVar, loc),
                                                                     intermediate.addConstantUnion(m, loc), loc);
  
                  structMember->setType(memberType);
  
                  // Assign each component of (possible) vector in struct member.
                  for (int component = 0; component < memberType.getVectorSize(); ++component) {
                      TIntermTyped* vec4Member = intermediate.addIndex(EOpIndexDirect,
                                                                       intermediate.addSymbol(*sampleShadow, loc),
                                                                       intermediate.addConstantUnion(vec4Pos++, loc), loc);
                      vec4Member->setType(TType(memberType.getBasicType(), EvqTemporary, 1));
  
                      TIntermTyped* memberAssign = nullptr;
  
                      if (memberType.isVector()) {
                          // Vector member: we need to create an access chain to the vector component.
  
                          TIntermTyped* structVecComponent = intermediate.addIndex(EOpIndexDirect, structMember,
                                                                                   intermediate.addConstantUnion(component, loc), loc);
                          
                          memberAssign = intermediate.addAssign(EOpAssign, structVecComponent, vec4Member, loc);
                      } else {
                          // Scalar member: we can assign to it directly.
                          memberAssign = intermediate.addAssign(EOpAssign, structMember, vec4Member, loc);
                      }
  
                      
                      conversionAggregate->getSequence().push_back(memberAssign);
                  }
              }
  
              // Add completed variable so the expression results in the whole struct value we just built.
              conversionAggregate->getSequence().push_back(intermediate.addSymbol(*structVar, loc));
  
              // Make it a sequence.
              intermediate.setAggregateOperator(conversionAggregate, EOpSequence, retType, loc);
          } else {
              // vector clamp the output if template vector type is smaller than sample result.
              if (retType.getVectorSize() < node->getVectorSize()) {
                  // Too many components.  Construct shorter vector from it.
                  const TOperator op = intermediate.mapTypeToConstructorOp(retType);
  
                  convertedResult = constructBuiltIn(retType, op, result, loc, false);
              } else {
                  // Enough components.  Use directly.
                  convertedResult = result;
              }
          }
  
          convertedResult->setLoc(loc);
          return convertedResult;
      };
  
      const TOperator op  = node->getAsOperator()->getOp();
      const TIntermAggregate* argAggregate = arguments ? arguments->getAsAggregate() : nullptr;
  
      // Bail out if not a sampler method.
      // Note though this is odd to do before checking the op, because the op
      // could be something that takes the arguments, and the function in question
      // takes the result of the op.  So, this is not the final word.
      if (arguments != nullptr) {
          if (argAggregate == nullptr) {
              if (arguments->getAsTyped()->getBasicType() != EbtSampler)
                  return;
          } else {
              if (argAggregate->getSequence().size() == 0 || 
                  argAggregate->getSequence()[0] == nullptr ||
                  argAggregate->getSequence()[0]->getAsTyped()->getBasicType() != EbtSampler)
                  return;
          }
      }
  
      switch (op) {
      // **** DX9 intrinsics: ****
      case EOpTexture:
          {
              // Texture with ddx & ddy is really gradient form in HLSL
              if (argAggregate->getSequence().size() == 4)
                  node->getAsAggregate()->setOperator(EOpTextureGrad);
  
              break;
          }
      case EOpTextureLod: //is almost EOpTextureBias (only args & operations are different)
          {
              TIntermTyped *argSamp = argAggregate->getSequence()[0]->getAsTyped();   // sampler
              TIntermTyped *argCoord = argAggregate->getSequence()[1]->getAsTyped();  // coord
  
              assert(argCoord->getVectorSize() == 4);
              TIntermTyped *w = intermediate.addConstantUnion(3, loc, true);
              TIntermTyped *argLod = intermediate.addIndex(EOpIndexDirect, argCoord, w, loc);
  
              TOperator constructOp = EOpNull;
              const TSampler &sampler = argSamp->getType().getSampler();
              int coordSize = 0;
  
              switch (sampler.dim)
              {
              case Esd1D:   constructOp = EOpConstructFloat; coordSize = 1; break; // 1D
              case Esd2D:   constructOp = EOpConstructVec2;  coordSize = 2; break; // 2D
              case Esd3D:   constructOp = EOpConstructVec3;  coordSize = 3; break; // 3D
              case EsdCube: constructOp = EOpConstructVec3;  coordSize = 3; break; // also 3D
              default:
                  break;
              }
  
              TIntermAggregate *constructCoord = new TIntermAggregate(constructOp);
              constructCoord->getSequence().push_back(argCoord);
              constructCoord->setLoc(loc);
              constructCoord->setType(TType(argCoord->getBasicType(), EvqTemporary, coordSize));
  
              TIntermAggregate *tex = new TIntermAggregate(EOpTextureLod);
              tex->getSequence().push_back(argSamp);        // sampler
              tex->getSequence().push_back(constructCoord); // coordinate
              tex->getSequence().push_back(argLod);         // lod
  
              node = convertReturn(tex, sampler);
  
              break;
          }
  
      case EOpTextureBias:
          {
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();  // sampler
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();  // coord
  
              // HLSL puts bias in W component of coordinate.  We extract it and add it to
              // the argument list, instead
              TIntermTyped* w = intermediate.addConstantUnion(3, loc, true);
              TIntermTyped* bias = intermediate.addIndex(EOpIndexDirect, arg1, w, loc);
  
              TOperator constructOp = EOpNull;
              const TSampler& sampler = arg0->getType().getSampler();
  
              switch (sampler.dim) {
              case Esd1D:   constructOp = EOpConstructFloat; break; // 1D
              case Esd2D:   constructOp = EOpConstructVec2;  break; // 2D
              case Esd3D:   constructOp = EOpConstructVec3;  break; // 3D
              case EsdCube: constructOp = EOpConstructVec3;  break; // also 3D
              default: break;
              }
  
              TIntermAggregate* constructCoord = new TIntermAggregate(constructOp);
              constructCoord->getSequence().push_back(arg1);
              constructCoord->setLoc(loc);
  
              // The input vector should never be less than 2, since there's always a bias.
              // The max is for safety, and should be a no-op.
              constructCoord->setType(TType(arg1->getBasicType(), EvqTemporary, std::max(arg1->getVectorSize() - 1, 0)));
  
              TIntermAggregate* tex = new TIntermAggregate(EOpTexture);
              tex->getSequence().push_back(arg0);           // sampler
              tex->getSequence().push_back(constructCoord); // coordinate
              tex->getSequence().push_back(bias);           // bias
  
              node = convertReturn(tex, sampler);
  
              break;
          }
  
      // **** DX10 methods: ****
      case EOpMethodSample:     // fall through
      case EOpMethodSampleBias: // ...
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
              TIntermTyped* argBias   = nullptr;
              TIntermTyped* argOffset = nullptr;
              const TSampler& sampler = argTex->getType().getSampler();
  
              int nextArg = 3;
  
              if (op == EOpMethodSampleBias)  // SampleBias has a bias arg
                  argBias = argAggregate->getSequence()[nextArg++]->getAsTyped();
  
              TOperator textureOp = EOpTexture;
  
              if ((int)argAggregate->getSequence().size() == (nextArg+1)) { // last parameter is offset form
                  textureOp = EOpTextureOffset;
                  argOffset = argAggregate->getSequence()[nextArg++]->getAsTyped();
              }
  
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
  
              TIntermAggregate* txsample = new TIntermAggregate(textureOp);
              txsample->getSequence().push_back(txcombine);
              txsample->getSequence().push_back(argCoord);
  
              if (argBias != nullptr)
                  txsample->getSequence().push_back(argBias);
  
              if (argOffset != nullptr)
                  txsample->getSequence().push_back(argOffset);
  
              node = convertReturn(txsample, sampler);
  
              break;
          }
  
      case EOpMethodSampleGrad: // ...
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
              TIntermTyped* argDDX    = argAggregate->getSequence()[3]->getAsTyped();
              TIntermTyped* argDDY    = argAggregate->getSequence()[4]->getAsTyped();
              TIntermTyped* argOffset = nullptr;
              const TSampler& sampler = argTex->getType().getSampler();
  
              TOperator textureOp = EOpTextureGrad;
  
              if (argAggregate->getSequence().size() == 6) { // last parameter is offset form
                  textureOp = EOpTextureGradOffset;
                  argOffset = argAggregate->getSequence()[5]->getAsTyped();
              }
  
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
  
              TIntermAggregate* txsample = new TIntermAggregate(textureOp);
              txsample->getSequence().push_back(txcombine);
              txsample->getSequence().push_back(argCoord);
              txsample->getSequence().push_back(argDDX);
              txsample->getSequence().push_back(argDDY);
  
              if (argOffset != nullptr)
                  txsample->getSequence().push_back(argOffset);
  
              node = convertReturn(txsample, sampler);
  
              break;
          }
  
      case EOpMethodGetDimensions:
          {
              // AST returns a vector of results, which we break apart component-wise into
              // separate values to assign to the HLSL method's outputs, ala:
              //  tx . GetDimensions(width, height);
              //      float2 sizeQueryTemp = EOpTextureQuerySize
              //      width = sizeQueryTemp.X;
              //      height = sizeQueryTemp.Y;
  
              TIntermTyped* argTex = argAggregate->getSequence()[0]->getAsTyped();
              const TType& texType = argTex->getType();
  
              assert(texType.getBasicType() == EbtSampler);
  
              const TSampler& sampler = texType.getSampler();
              const TSamplerDim dim = sampler.dim;
              const bool isImage = sampler.isImage();
              const bool isMs = sampler.isMultiSample();
              const int numArgs = (int)argAggregate->getSequence().size();
  
              int numDims = 0;
  
              switch (dim) {
              case Esd1D:     numDims = 1; break; // W
              case Esd2D:     numDims = 2; break; // W, H
              case Esd3D:     numDims = 3; break; // W, H, D
              case EsdCube:   numDims = 2; break; // W, H (cube)
              case EsdBuffer: numDims = 1; break; // W (buffers)
              case EsdRect:   numDims = 2; break; // W, H (rect)
              default:
                  assert(0 && "unhandled texture dimension");
              }
  
              // Arrayed adds another dimension for the number of array elements
              if (sampler.isArrayed())
                  ++numDims;
  
              // Establish whether the method itself is querying mip levels.  This can be false even
              // if the underlying query requires a MIP level, due to the available HLSL method overloads.
              const bool mipQuery = (numArgs > (numDims + 1 + (isMs ? 1 : 0)));
  
              // Establish whether we must use the LOD form of query (even if the method did not supply a mip level to query).
              // True if:
              //   1. 1D/2D/3D/Cube AND multisample==0 AND NOT image (those can be sent to the non-LOD query)
              // or,
              //   2. There is a LOD (because the non-LOD query cannot be used in that case, per spec)
              const bool mipRequired =
                  ((dim == Esd1D || dim == Esd2D || dim == Esd3D || dim == EsdCube) && !isMs && !isImage) || // 1...
                  mipQuery; // 2...
  
              // AST assumes integer return.  Will be converted to float if required.
              TIntermAggregate* sizeQuery = new TIntermAggregate(isImage ? EOpImageQuerySize : EOpTextureQuerySize);
              sizeQuery->getSequence().push_back(argTex);
  
              // If we're building an LOD query, add the LOD.
              if (mipRequired) {
                  // If the base HLSL query had no MIP level given, use level 0.
                  TIntermTyped* queryLod = mipQuery ? argAggregate->getSequence()[1]->getAsTyped() :
                      intermediate.addConstantUnion(0, loc, true);
                  sizeQuery->getSequence().push_back(queryLod);
              }
  
              sizeQuery->setType(TType(EbtUint, EvqTemporary, numDims));
              sizeQuery->setLoc(loc);
  
              // Return value from size query
              TVariable* tempArg = makeInternalVariable("sizeQueryTemp", sizeQuery->getType());
              tempArg->getWritableType().getQualifier().makeTemporary();
              TIntermTyped* sizeQueryAssign = intermediate.addAssign(EOpAssign,
                                                                     intermediate.addSymbol(*tempArg, loc),
                                                                     sizeQuery, loc);
  
              // Compound statement for assigning outputs
              TIntermAggregate* compoundStatement = intermediate.makeAggregate(sizeQueryAssign, loc);
              // Index of first output parameter
              const int outParamBase = mipQuery ? 2 : 1;
  
              for (int compNum = 0; compNum < numDims; ++compNum) {
                  TIntermTyped* indexedOut = nullptr;
                  TIntermSymbol* sizeQueryReturn = intermediate.addSymbol(*tempArg, loc);
  
                  if (numDims > 1) {
                      TIntermTyped* component = intermediate.addConstantUnion(compNum, loc, true);
                      indexedOut = intermediate.addIndex(EOpIndexDirect, sizeQueryReturn, component, loc);
                      indexedOut->setType(TType(EbtUint, EvqTemporary, 1));
                      indexedOut->setLoc(loc);
                  } else {
                      indexedOut = sizeQueryReturn;
                  }
  
                  TIntermTyped* outParam = argAggregate->getSequence()[outParamBase + compNum]->getAsTyped();
                  TIntermTyped* compAssign = intermediate.addAssign(EOpAssign, outParam, indexedOut, loc);
  
                  compoundStatement = intermediate.growAggregate(compoundStatement, compAssign);
              }
  
              // handle mip level parameter
              if (mipQuery) {
                  TIntermTyped* outParam = argAggregate->getSequence()[outParamBase + numDims]->getAsTyped();
  
                  TIntermAggregate* levelsQuery = new TIntermAggregate(EOpTextureQueryLevels);
                  levelsQuery->getSequence().push_back(argTex);
                  levelsQuery->setType(TType(EbtUint, EvqTemporary, 1));
                  levelsQuery->setLoc(loc);
  
                  TIntermTyped* compAssign = intermediate.addAssign(EOpAssign, outParam, levelsQuery, loc);
                  compoundStatement = intermediate.growAggregate(compoundStatement, compAssign);
              }
  
              // 2DMS formats query # samples, which needs a different query op
              if (sampler.isMultiSample()) {
                  TIntermTyped* outParam = argAggregate->getSequence()[outParamBase + numDims]->getAsTyped();
  
                  TIntermAggregate* samplesQuery = new TIntermAggregate(EOpImageQuerySamples);
                  samplesQuery->getSequence().push_back(argTex);
                  samplesQuery->setType(TType(EbtUint, EvqTemporary, 1));
                  samplesQuery->setLoc(loc);
  
                  TIntermTyped* compAssign = intermediate.addAssign(EOpAssign, outParam, samplesQuery, loc);
                  compoundStatement = intermediate.growAggregate(compoundStatement, compAssign);
              }
  
              compoundStatement->setOperator(EOpSequence);
              compoundStatement->setLoc(loc);
              compoundStatement->setType(TType(EbtVoid));
  
              node = compoundStatement;
  
              break;
          }
  
      case EOpMethodSampleCmp:  // fall through...
      case EOpMethodSampleCmpLevelZero:
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
              TIntermTyped* argCmpVal = argAggregate->getSequence()[3]->getAsTyped();
              TIntermTyped* argOffset = nullptr;
  
              // Sampler argument should be a sampler.
              if (argSamp->getType().getBasicType() != EbtSampler) {
                  error(loc, "expected: sampler type", "", "");
                  return;
              }
  
              // Sampler should be a SamplerComparisonState
              if (! argSamp->getType().getSampler().isShadow()) {
                  error(loc, "expected: SamplerComparisonState", "", "");
                  return;
              }
  
              // optional offset value
              if (argAggregate->getSequence().size() > 4)
                  argOffset = argAggregate->getSequence()[4]->getAsTyped();
  
              const int coordDimWithCmpVal = argCoord->getType().getVectorSize() + 1; // +1 for cmp
  
              // AST wants comparison value as one of the texture coordinates
              TOperator constructOp = EOpNull;
              switch (coordDimWithCmpVal) {
              // 1D can't happen: there's always at least 1 coordinate dimension + 1 cmp val
              case 2: constructOp = EOpConstructVec2;  break;
              case 3: constructOp = EOpConstructVec3;  break;
              case 4: constructOp = EOpConstructVec4;  break;
              case 5: constructOp = EOpConstructVec4;  break; // cubeArrayShadow, cmp value is separate arg.
              default: assert(0); break;
              }
  
              TIntermAggregate* coordWithCmp = new TIntermAggregate(constructOp);
              coordWithCmp->getSequence().push_back(argCoord);
              if (coordDimWithCmpVal != 5) // cube array shadow is special.
                  coordWithCmp->getSequence().push_back(argCmpVal);
              coordWithCmp->setLoc(loc);
              coordWithCmp->setType(TType(argCoord->getBasicType(), EvqTemporary, std::min(coordDimWithCmpVal, 4)));
  
              TOperator textureOp = (op == EOpMethodSampleCmpLevelZero ? EOpTextureLod : EOpTexture);
              if (argOffset != nullptr)
                  textureOp = (op == EOpMethodSampleCmpLevelZero ? EOpTextureLodOffset : EOpTextureOffset);
  
              // Create combined sampler & texture op
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
              TIntermAggregate* txsample = new TIntermAggregate(textureOp);
              txsample->getSequence().push_back(txcombine);
              txsample->getSequence().push_back(coordWithCmp);
  
              if (coordDimWithCmpVal == 5) // cube array shadow is special: cmp val follows coord.
                  txsample->getSequence().push_back(argCmpVal);
  
              // the LevelZero form uses 0 as an explicit LOD
              if (op == EOpMethodSampleCmpLevelZero)
                  txsample->getSequence().push_back(intermediate.addConstantUnion(0.0, EbtFloat, loc, true));
  
              // Add offset if present
              if (argOffset != nullptr)
                  txsample->getSequence().push_back(argOffset);
  
              txsample->setType(node->getType());
              txsample->setLoc(loc);
              node = txsample;
  
              break;
          }
  
      case EOpMethodLoad:
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argOffset = nullptr;
              TIntermTyped* lodComponent = nullptr;
              TIntermTyped* coordSwizzle = nullptr;
  
              const TSampler& sampler = argTex->getType().getSampler();
              const bool isMS = sampler.isMultiSample();
              const bool isBuffer = sampler.dim == EsdBuffer;
              const bool isImage = sampler.isImage();
              const TBasicType coordBaseType = argCoord->getType().getBasicType();
  
              // Last component of coordinate is the mip level, for non-MS.  we separate them here:
              if (isMS || isBuffer || isImage) {
                  // MS, Buffer, and Image have no LOD
                  coordSwizzle = argCoord;
              } else {
                  // Extract coordinate
                  int swizzleSize = argCoord->getType().getVectorSize() - (isMS ? 0 : 1);
                  TSwizzleSelectors<TVectorSelector> coordFields;
                  for (int i = 0; i < swizzleSize; ++i)
                      coordFields.push_back(i);
                  TIntermTyped* coordIdx = intermediate.addSwizzle(coordFields, loc);
                  coordSwizzle = intermediate.addIndex(EOpVectorSwizzle, argCoord, coordIdx, loc);
                  coordSwizzle->setType(TType(coordBaseType, EvqTemporary, coordFields.size()));
  
                  // Extract LOD
                  TIntermTyped* lodIdx = intermediate.addConstantUnion(coordFields.size(), loc, true);
                  lodComponent = intermediate.addIndex(EOpIndexDirect, argCoord, lodIdx, loc);
                  lodComponent->setType(TType(coordBaseType, EvqTemporary, 1));
              }
  
              const int numArgs    = (int)argAggregate->getSequence().size();
              const bool hasOffset = ((!isMS && numArgs == 3) || (isMS && numArgs == 4));
  
              // Create texel fetch
              const TOperator fetchOp = (isImage   ? EOpImageLoad :
                                         hasOffset ? EOpTextureFetchOffset :
                                         EOpTextureFetch);
              TIntermAggregate* txfetch = new TIntermAggregate(fetchOp);
  
              // Build up the fetch
              txfetch->getSequence().push_back(argTex);
              txfetch->getSequence().push_back(coordSwizzle);
  
              if (isMS) {
                  // add 2DMS sample index
                  TIntermTyped* argSampleIdx  = argAggregate->getSequence()[2]->getAsTyped();
                  txfetch->getSequence().push_back(argSampleIdx);
              } else if (isBuffer) {
                  // Nothing else to do for buffers.
              } else if (isImage) {
                  // Nothing else to do for images.
              } else {
                  // 2DMS and buffer have no LOD, but everything else does.
                  txfetch->getSequence().push_back(lodComponent);
              }
  
              // Obtain offset arg, if there is one.
              if (hasOffset) {
                  const int offsetPos  = (isMS ? 3 : 2);
                  argOffset = argAggregate->getSequence()[offsetPos]->getAsTyped();
                  txfetch->getSequence().push_back(argOffset);
              }
  
              node = convertReturn(txfetch, sampler);
  
              break;
          }
  
      case EOpMethodSampleLevel:
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
              TIntermTyped* argLod    = argAggregate->getSequence()[3]->getAsTyped();
              TIntermTyped* argOffset = nullptr;
              const TSampler& sampler = argTex->getType().getSampler();
  
              const int  numArgs = (int)argAggregate->getSequence().size();
  
              if (numArgs == 5) // offset, if present
                  argOffset = argAggregate->getSequence()[4]->getAsTyped();
  
              const TOperator textureOp = (argOffset == nullptr ? EOpTextureLod : EOpTextureLodOffset);
              TIntermAggregate* txsample = new TIntermAggregate(textureOp);
  
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
  
              txsample->getSequence().push_back(txcombine);
              txsample->getSequence().push_back(argCoord);
              txsample->getSequence().push_back(argLod);
  
              if (argOffset != nullptr)
                  txsample->getSequence().push_back(argOffset);
  
              node = convertReturn(txsample, sampler);
  
              break;
          }
  
      case EOpMethodGather:
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
              TIntermTyped* argOffset = nullptr;
  
              // Offset is optional
              if (argAggregate->getSequence().size() > 3)
                  argOffset = argAggregate->getSequence()[3]->getAsTyped();
  
              const TOperator textureOp = (argOffset == nullptr ? EOpTextureGather : EOpTextureGatherOffset);
              TIntermAggregate* txgather = new TIntermAggregate(textureOp);
  
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
  
              txgather->getSequence().push_back(txcombine);
              txgather->getSequence().push_back(argCoord);
              // Offset if not given is implicitly channel 0 (red)
  
              if (argOffset != nullptr)
                  txgather->getSequence().push_back(argOffset);
  
              txgather->setType(node->getType());
              txgather->setLoc(loc);
              node = txgather;
  
              break;
          }
  
      case EOpMethodGatherRed:      // fall through...
      case EOpMethodGatherGreen:    // ...
      case EOpMethodGatherBlue:     // ...
      case EOpMethodGatherAlpha:    // ...
      case EOpMethodGatherCmpRed:   // ...
      case EOpMethodGatherCmpGreen: // ...
      case EOpMethodGatherCmpBlue:  // ...
      case EOpMethodGatherCmpAlpha: // ...
          {
              int channel = 0;    // the channel we are gathering
              int cmpValues = 0;  // 1 if there is a compare value (handier than a bool below)
  
              switch (op) {
              case EOpMethodGatherCmpRed:   cmpValues = 1;  // fall through
              case EOpMethodGatherRed:      channel = 0; break;
              case EOpMethodGatherCmpGreen: cmpValues = 1;  // fall through
              case EOpMethodGatherGreen:    channel = 1; break;
              case EOpMethodGatherCmpBlue:  cmpValues = 1;  // fall through
              case EOpMethodGatherBlue:     channel = 2; break;
              case EOpMethodGatherCmpAlpha: cmpValues = 1;  // fall through
              case EOpMethodGatherAlpha:    channel = 3; break;
              default:                      assert(0);   break;
              }
  
              // For now, we have nothing to map the component-wise comparison forms
              // to, because neither GLSL nor SPIR-V has such an opcode.  Issue an
              // unimplemented error instead.  Most of the machinery is here if that
              // should ever become available.  However, red can be passed through
              // to OpImageDrefGather.  G/B/A cannot, because that opcode does not
              // accept a component.
              if (cmpValues != 0 && op != EOpMethodGatherCmpRed) {
                  error(loc, "unimplemented: component-level gather compare", "", "");
                  return;
              }
  
              int arg = 0;
  
              TIntermTyped* argTex        = argAggregate->getSequence()[arg++]->getAsTyped();
              TIntermTyped* argSamp       = argAggregate->getSequence()[arg++]->getAsTyped();
              TIntermTyped* argCoord      = argAggregate->getSequence()[arg++]->getAsTyped();
              TIntermTyped* argOffset     = nullptr;
              TIntermTyped* argOffsets[4] = { nullptr, nullptr, nullptr, nullptr };
              // TIntermTyped* argStatus     = nullptr; // TODO: residency
              TIntermTyped* argCmp        = nullptr;
  
              const TSamplerDim dim = argTex->getType().getSampler().dim;
  
              const int  argSize = (int)argAggregate->getSequence().size();
              bool hasStatus     = (argSize == (5+cmpValues) || argSize == (8+cmpValues));
              bool hasOffset1    = false;
              bool hasOffset4    = false;
  
              // Sampler argument should be a sampler.
              if (argSamp->getType().getBasicType() != EbtSampler) {
                  error(loc, "expected: sampler type", "", "");
                  return;
              }
  
              // Cmp forms require SamplerComparisonState
              if (cmpValues > 0 && ! argSamp->getType().getSampler().isShadow()) {
                  error(loc, "expected: SamplerComparisonState", "", "");
                  return;
              }
  
              // Only 2D forms can have offsets.  Discover if we have 0, 1 or 4 offsets.
              if (dim == Esd2D) {
                  hasOffset1 = (argSize == (4+cmpValues) || argSize == (5+cmpValues));
                  hasOffset4 = (argSize == (7+cmpValues) || argSize == (8+cmpValues));
              }
  
              assert(!(hasOffset1 && hasOffset4));
  
              TOperator textureOp = EOpTextureGather;
  
              // Compare forms have compare value
              if (cmpValues != 0)
                  argCmp = argOffset = argAggregate->getSequence()[arg++]->getAsTyped();
  
              // Some forms have single offset
              if (hasOffset1) {
                  textureOp = EOpTextureGatherOffset;   // single offset form
                  argOffset = argAggregate->getSequence()[arg++]->getAsTyped();
              }
  
              // Some forms have 4 gather offsets
              if (hasOffset4) {
                  textureOp = EOpTextureGatherOffsets;  // note plural, for 4 offset form
                  for (int offsetNum = 0; offsetNum < 4; ++offsetNum)
                      argOffsets[offsetNum] = argAggregate->getSequence()[arg++]->getAsTyped();
              }
  
              // Residency status
              if (hasStatus) {
                  // argStatus = argAggregate->getSequence()[arg++]->getAsTyped();
                  error(loc, "unimplemented: residency status", "", "");
                  return;
              }
  
              TIntermAggregate* txgather = new TIntermAggregate(textureOp);
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
  
              TIntermTyped* argChannel = intermediate.addConstantUnion(channel, loc, true);
  
              txgather->getSequence().push_back(txcombine);
              txgather->getSequence().push_back(argCoord);
  
              // AST wants an array of 4 offsets, where HLSL has separate args.  Here
              // we construct an array from the separate args.
              if (hasOffset4) {
                  TType arrayType(EbtInt, EvqTemporary, 2);
                  TArraySizes* arraySizes = new TArraySizes;
                  arraySizes->addInnerSize(4);
                  arrayType.transferArraySizes(arraySizes);
  
                  TIntermAggregate* initList = new TIntermAggregate(EOpNull);
  
                  for (int offsetNum = 0; offsetNum < 4; ++offsetNum)
                      initList->getSequence().push_back(argOffsets[offsetNum]);
  
                  argOffset = addConstructor(loc, initList, arrayType);
              }
  
              // Add comparison value if we have one
              if (argCmp != nullptr)
                  txgather->getSequence().push_back(argCmp);
  
              // Add offset (either 1, or an array of 4) if we have one
              if (argOffset != nullptr)
                  txgather->getSequence().push_back(argOffset);
  
              // Add channel value if the sampler is not shadow
              if (! argSamp->getType().getSampler().isShadow())
                  txgather->getSequence().push_back(argChannel);
  
              txgather->setType(node->getType());
              txgather->setLoc(loc);
              node = txgather;
  
              break;
          }
  
      case EOpMethodCalculateLevelOfDetail:
      case EOpMethodCalculateLevelOfDetailUnclamped:
          {
              TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
  
              TIntermAggregate* txquerylod = new TIntermAggregate(EOpTextureQueryLod);
  
              TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
              txquerylod->getSequence().push_back(txcombine);
              txquerylod->getSequence().push_back(argCoord);
  
              TIntermTyped* lodComponent = intermediate.addConstantUnion(
                  op == EOpMethodCalculateLevelOfDetail ? 0 : 1,
                  loc, true);
              TIntermTyped* lodComponentIdx = intermediate.addIndex(EOpIndexDirect, txquerylod, lodComponent, loc);
              lodComponentIdx->setType(TType(EbtFloat, EvqTemporary, 1));
              node = lodComponentIdx;
  
              break;
          }
  
      case EOpMethodGetSamplePosition:
          {
              // TODO: this entire decomposition exists because there is not yet a way to query
              // the sample position directly through SPIR-V.  Instead, we return fixed sample
              // positions for common cases.  *** If the sample positions are set differently,
              // this will be wrong. ***
  
              TIntermTyped* argTex     = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* argSampIdx = argAggregate->getSequence()[1]->getAsTyped();
  
              TIntermAggregate* samplesQuery = new TIntermAggregate(EOpImageQuerySamples);
              samplesQuery->getSequence().push_back(argTex);
              samplesQuery->setType(TType(EbtUint, EvqTemporary, 1));
              samplesQuery->setLoc(loc);
  
              TIntermAggregate* compoundStatement = nullptr;
  
              TVariable* outSampleCount = makeInternalVariable("@sampleCount", TType(EbtUint));
              outSampleCount->getWritableType().getQualifier().makeTemporary();
              TIntermTyped* compAssign = intermediate.addAssign(EOpAssign, intermediate.addSymbol(*outSampleCount, loc),
                                                                samplesQuery, loc);
              compoundStatement = intermediate.growAggregate(compoundStatement, compAssign);
  
              TIntermTyped* idxtest[4];
  
              // Create tests against 2, 4, 8, and 16 sample values
              int count = 0;
              for (int val = 2; val <= 16; val *= 2)
                  idxtest[count++] =
                      intermediate.addBinaryNode(EOpEqual, 
                                                 intermediate.addSymbol(*outSampleCount, loc),
                                                 intermediate.addConstantUnion(val, loc),
                                                 loc, TType(EbtBool));
  
              const TOperator idxOp = (argSampIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect : EOpIndexIndirect;
              
              // Create index ops into position arrays given sample index.
              // TODO: should it be clamped?
              TIntermTyped* index[4];
              count = 0;
              for (int val = 2; val <= 16; val *= 2) {
                  index[count] = intermediate.addIndex(idxOp, getSamplePosArray(val), argSampIdx, loc);
                  index[count++]->setType(TType(EbtFloat, EvqTemporary, 2));
              }
  
              // Create expression as:
              // (sampleCount == 2)  ? pos2[idx] :
              // (sampleCount == 4)  ? pos4[idx] :
              // (sampleCount == 8)  ? pos8[idx] :
              // (sampleCount == 16) ? pos16[idx] : float2(0,0);
              TIntermTyped* test = 
                  intermediate.addSelection(idxtest[0], index[0], 
                      intermediate.addSelection(idxtest[1], index[1], 
                          intermediate.addSelection(idxtest[2], index[2],
                              intermediate.addSelection(idxtest[3], index[3], 
                                                        getSamplePosArray(1), loc), loc), loc), loc);
                                           
              compoundStatement = intermediate.growAggregate(compoundStatement, test);
              compoundStatement->setOperator(EOpSequence);
              compoundStatement->setLoc(loc);
              compoundStatement->setType(TType(EbtFloat, EvqTemporary, 2));
  
              node = compoundStatement;
  
              break;
          }
  
      case EOpSubpassLoad:
          {
              const TIntermTyped* argSubpass = 
                  argAggregate ? argAggregate->getSequence()[0]->getAsTyped() :
                  arguments->getAsTyped();
  
              const TSampler& sampler = argSubpass->getType().getSampler();
  
              // subpass load: the multisample form is overloaded.  Here, we convert that to
              // the EOpSubpassLoadMS opcode.
              if (argAggregate != nullptr && argAggregate->getSequence().size() > 1)
                  node->getAsOperator()->setOp(EOpSubpassLoadMS);
  
              node = convertReturn(node, sampler);
  
              break;
          }
          
  
      default:
          break; // most pass through unchanged
      }
  }
  
  //
  // Decompose geometry shader methods
  //
  void HlslParseContext::decomposeGeometryMethods(const TSourceLoc& loc, TIntermTyped*& node, TIntermNode* arguments)
  {
      if (node == nullptr || !node->getAsOperator())
          return;
  
      const TOperator op  = node->getAsOperator()->getOp();
      const TIntermAggregate* argAggregate = arguments ? arguments->getAsAggregate() : nullptr;
  
      switch (op) {
      case EOpMethodAppend:
          if (argAggregate) {
              // Don't emit these for non-GS stage, since we won't have the gsStreamOutput symbol.
              if (language != EShLangGeometry) {
                  node = nullptr;
                  return;
              }
  
              TIntermAggregate* sequence = nullptr;
              TIntermAggregate* emit = new TIntermAggregate(EOpEmitVertex);
  
              emit->setLoc(loc);
              emit->setType(TType(EbtVoid));
  
              TIntermTyped* data = argAggregate->getSequence()[1]->getAsTyped();
  
              // This will be patched in finalization during finalizeAppendMethods()
              sequence = intermediate.growAggregate(sequence, data, loc);
              sequence = intermediate.growAggregate(sequence, emit);
  
              sequence->setOperator(EOpSequence);
              sequence->setLoc(loc);
              sequence->setType(TType(EbtVoid));
  
              gsAppends.push_back({sequence, loc});
  
              node = sequence;
          }
          break;
  
      case EOpMethodRestartStrip:
          {
              // Don't emit these for non-GS stage, since we won't have the gsStreamOutput symbol.
              if (language != EShLangGeometry) {
                  node = nullptr;
                  return;
              }
  
              TIntermAggregate* cut = new TIntermAggregate(EOpEndPrimitive);
              cut->setLoc(loc);
              cut->setType(TType(EbtVoid));
              node = cut;
          }
          break;
  
      default:
          break; // most pass through unchanged
      }
  }
  
  //
  // Optionally decompose intrinsics to AST opcodes.
  //
  void HlslParseContext::decomposeIntrinsic(const TSourceLoc& loc, TIntermTyped*& node, TIntermNode* arguments)
  {
      // Helper to find image data for image atomics:
      // OpImageLoad(image[idx])
      // We take the image load apart and add its params to the atomic op aggregate node
      const auto imageAtomicParams = [this, &loc, &node](TIntermAggregate* atomic, TIntermTyped* load) {
          TIntermAggregate* loadOp = load->getAsAggregate();
          if (loadOp == nullptr) {
              error(loc, "unknown image type in atomic operation", "", "");
              node = nullptr;
              return;
          }
  
          atomic->getSequence().push_back(loadOp->getSequence()[0]);
          atomic->getSequence().push_back(loadOp->getSequence()[1]);
      };
  
      // Return true if this is an imageLoad, which we will change to an image atomic.
      const auto isImageParam = [](TIntermTyped* image) -> bool {
          TIntermAggregate* imageAggregate = image->getAsAggregate();
          return imageAggregate != nullptr && imageAggregate->getOp() == EOpImageLoad;
      };
  
      const auto lookupBuiltinVariable = [&](const char* name, TBuiltInVariable builtin, TType& type) -> TIntermTyped* {
          TSymbol* symbol = symbolTable.find(name);
          if (nullptr == symbol) {
              type.getQualifier().builtIn = builtin;
  
              TVariable* variable = new TVariable(NewPoolTString(name), type);
  
              symbolTable.insert(*variable);
  
              symbol = symbolTable.find(name);
              assert(symbol && "Inserted symbol could not be found!");
          }
  
          return intermediate.addSymbol(*(symbol->getAsVariable()), loc);
      };
  
      // HLSL intrinsics can be pass through to native AST opcodes, or decomposed here to existing AST
      // opcodes for compatibility with existing software stacks.
      static const bool decomposeHlslIntrinsics = true;
  
      if (!decomposeHlslIntrinsics || !node || !node->getAsOperator())
          return;
  
      const TIntermAggregate* argAggregate = arguments ? arguments->getAsAggregate() : nullptr;
      TIntermUnary* fnUnary = node->getAsUnaryNode();
      const TOperator op  = node->getAsOperator()->getOp();
  
      switch (op) {
      case EOpGenMul:
          {
              // mul(a,b) -> MatrixTimesMatrix, MatrixTimesVector, MatrixTimesScalar, VectorTimesScalar, Dot, Mul
              // Since we are treating HLSL rows like GLSL columns (the first matrix indirection),
              // we must reverse the operand order here.  Hence, arg0 gets sequence[1], etc.
              TIntermTyped* arg0 = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* arg1 = argAggregate->getSequence()[0]->getAsTyped();
  
              if (arg0->isVector() && arg1->isVector()) {  // vec * vec
                  node->getAsAggregate()->setOperator(EOpDot);
              } else {
                  node = handleBinaryMath(loc, "mul", EOpMul, arg0, arg1);
              }
  
              break;
          }
  
      case EOpRcp:
          {
              // rcp(a) -> 1 / a
              TIntermTyped* arg0 = fnUnary->getOperand();
              TBasicType   type0 = arg0->getBasicType();
              TIntermTyped* one  = intermediate.addConstantUnion(1, type0, loc, true);
              node  = handleBinaryMath(loc, "rcp", EOpDiv, one, arg0);
  
              break;
          }
  
      case EOpAny: // fall through
      case EOpAll:
          {
              TIntermTyped* typedArg = arguments->getAsTyped();
  
              // HLSL allows float/etc types here, and the SPIR-V opcode requires a bool.
              // We'll convert here.  Note that for efficiency, we could add a smarter
              // decomposition for some type cases, e.g, maybe by decomposing a dot product.
              if (typedArg->getType().getBasicType() != EbtBool) {
                  const TType boolType(EbtBool, EvqTemporary,
                                       typedArg->getVectorSize(),
                                       typedArg->getMatrixCols(),
                                       typedArg->getMatrixRows(),
                                       typedArg->isVector());
  
                  typedArg = intermediate.addConversion(EOpConstructBool, boolType, typedArg);
                  node->getAsUnaryNode()->setOperand(typedArg);
              }
  
              break;
          }
  
      case EOpSaturate:
          {
              // saturate(a) -> clamp(a,0,1)
              TIntermTyped* arg0 = fnUnary->getOperand();
              TBasicType   type0 = arg0->getBasicType();
              TIntermAggregate* clamp = new TIntermAggregate(EOpClamp);
  
              clamp->getSequence().push_back(arg0);
              clamp->getSequence().push_back(intermediate.addConstantUnion(0, type0, loc, true));
              clamp->getSequence().push_back(intermediate.addConstantUnion(1, type0, loc, true));
              clamp->setLoc(loc);
              clamp->setType(node->getType());
              clamp->getWritableType().getQualifier().makeTemporary();
              node = clamp;
  
              break;
          }
  
      case EOpSinCos:
          {
              // sincos(a,b,c) -> b = sin(a), c = cos(a)
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* arg2 = argAggregate->getSequence()[2]->getAsTyped();
  
              TIntermTyped* sinStatement = handleUnaryMath(loc, "sin", EOpSin, arg0);
              TIntermTyped* cosStatement = handleUnaryMath(loc, "cos", EOpCos, arg0);
              TIntermTyped* sinAssign    = intermediate.addAssign(EOpAssign, arg1, sinStatement, loc);
              TIntermTyped* cosAssign    = intermediate.addAssign(EOpAssign, arg2, cosStatement, loc);
  
              TIntermAggregate* compoundStatement = intermediate.makeAggregate(sinAssign, loc);
              compoundStatement = intermediate.growAggregate(compoundStatement, cosAssign);
              compoundStatement->setOperator(EOpSequence);
              compoundStatement->setLoc(loc);
              compoundStatement->setType(TType(EbtVoid));
  
              node = compoundStatement;
  
              break;
          }
  
      case EOpClip:
          {
              // clip(a) -> if (any(a<0)) discard;
              TIntermTyped*  arg0 = fnUnary->getOperand();
              TBasicType     type0 = arg0->getBasicType();
              TIntermTyped*  compareNode = nullptr;
  
              // For non-scalars: per experiment with FXC compiler, discard if any component < 0.
              if (!arg0->isScalar()) {
                  // component-wise compare: a < 0
                  TIntermAggregate* less = new TIntermAggregate(EOpLessThan);
                  less->getSequence().push_back(arg0);
                  less->setLoc(loc);
  
                  // make vec or mat of bool matching dimensions of input
                  less->setType(TType(EbtBool, EvqTemporary,
                                      arg0->getType().getVectorSize(),
                                      arg0->getType().getMatrixCols(),
                                      arg0->getType().getMatrixRows(),
                                      arg0->getType().isVector()));
  
                  // calculate # of components for comparison const
                  const int constComponentCount =
                      std::max(arg0->getType().getVectorSize(), 1) *
                      std::max(arg0->getType().getMatrixCols(), 1) *
                      std::max(arg0->getType().getMatrixRows(), 1);
  
                  TConstUnion zero;
                  if (arg0->getType().isIntegerDomain())
                      zero.setDConst(0);
                  else
                      zero.setDConst(0.0);
                  TConstUnionArray zeros(constComponentCount, zero);
  
                  less->getSequence().push_back(intermediate.addConstantUnion(zeros, arg0->getType(), loc, true));
  
                  compareNode = intermediate.addBuiltInFunctionCall(loc, EOpAny, true, less, TType(EbtBool));
              } else {
                  TIntermTyped* zero;
                  if (arg0->getType().isIntegerDomain())
                      zero = intermediate.addConstantUnion(0, loc, true);
                  else
                      zero = intermediate.addConstantUnion(0.0, type0, loc, true);
                  compareNode = handleBinaryMath(loc, "clip", EOpLessThan, arg0, zero);
              }
  
              TIntermBranch* killNode = intermediate.addBranch(EOpKill, loc);
  
              node = new TIntermSelection(compareNode, killNode, nullptr);
              node->setLoc(loc);
  
              break;
          }
  
      case EOpLog10:
          {
              // log10(a) -> log2(a) * 0.301029995663981  (== 1/log2(10))
              TIntermTyped* arg0 = fnUnary->getOperand();
              TIntermTyped* log2 = handleUnaryMath(loc, "log2", EOpLog2, arg0);
              TIntermTyped* base = intermediate.addConstantUnion(0.301029995663981f, EbtFloat, loc, true);
  
              node  = handleBinaryMath(loc, "mul", EOpMul, log2, base);
  
              break;
          }
  
      case EOpDst:
          {
              // dest.x = 1;
              // dest.y = src0.y * src1.y;
              // dest.z = src0.z;
              // dest.w = src1.w;
  
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();
  
              TIntermTyped* y = intermediate.addConstantUnion(1, loc, true);
              TIntermTyped* z = intermediate.addConstantUnion(2, loc, true);
              TIntermTyped* w = intermediate.addConstantUnion(3, loc, true);
  
              TIntermTyped* src0y = intermediate.addIndex(EOpIndexDirect, arg0, y, loc);
              TIntermTyped* src1y = intermediate.addIndex(EOpIndexDirect, arg1, y, loc);
              TIntermTyped* src0z = intermediate.addIndex(EOpIndexDirect, arg0, z, loc);
              TIntermTyped* src1w = intermediate.addIndex(EOpIndexDirect, arg1, w, loc);
  
              TIntermAggregate* dst = new TIntermAggregate(EOpConstructVec4);
  
              dst->getSequence().push_back(intermediate.addConstantUnion(1.0, EbtFloat, loc, true));
              dst->getSequence().push_back(handleBinaryMath(loc, "mul", EOpMul, src0y, src1y));
              dst->getSequence().push_back(src0z);
              dst->getSequence().push_back(src1w);
              dst->setType(TType(EbtFloat, EvqTemporary, 4));
              dst->setLoc(loc);
              node = dst;
  
              break;
          }
  
      case EOpInterlockedAdd: // optional last argument (if present) is assigned from return value
      case EOpInterlockedMin: // ...
      case EOpInterlockedMax: // ...
      case EOpInterlockedAnd: // ...
      case EOpInterlockedOr:  // ...
      case EOpInterlockedXor: // ...
      case EOpInterlockedExchange: // always has output arg
          {
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();  // dest
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();  // value
              TIntermTyped* arg2 = nullptr;
  
              if (argAggregate->getSequence().size() > 2)
                  arg2 = argAggregate->getSequence()[2]->getAsTyped();
  
              const bool isImage = isImageParam(arg0);
              const TOperator atomicOp = mapAtomicOp(loc, op, isImage);
              TIntermAggregate* atomic = new TIntermAggregate(atomicOp);
              atomic->setType(arg0->getType());
              atomic->getWritableType().getQualifier().makeTemporary();
              atomic->setLoc(loc);
  
              if (isImage) {
                  // orig_value = imageAtomicOp(image, loc, data)
                  imageAtomicParams(atomic, arg0);
                  atomic->getSequence().push_back(arg1);
  
                  if (argAggregate->getSequence().size() > 2) {
                      node = intermediate.addAssign(EOpAssign, arg2, atomic, loc);
                  } else {
                      node = atomic; // no assignment needed, as there was no out var.
                  }
              } else {
                  // Normal memory variable:
                  // arg0 = mem, arg1 = data, arg2(optional,out) = orig_value
                  if (argAggregate->getSequence().size() > 2) {
                      // optional output param is present.  return value goes to arg2.
                      atomic->getSequence().push_back(arg0);
                      atomic->getSequence().push_back(arg1);
  
                      node = intermediate.addAssign(EOpAssign, arg2, atomic, loc);
                  } else {
                      // Set the matching operator.  Since output is absent, this is all we need to do.
                      node->getAsAggregate()->setOperator(atomicOp);
                      node->setType(atomic->getType());
                  }
              }
  
              break;
          }
  
      case EOpInterlockedCompareExchange:
          {
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();  // dest
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();  // cmp
              TIntermTyped* arg2 = argAggregate->getSequence()[2]->getAsTyped();  // value
              TIntermTyped* arg3 = argAggregate->getSequence()[3]->getAsTyped();  // orig
  
              const bool isImage = isImageParam(arg0);
              TIntermAggregate* atomic = new TIntermAggregate(mapAtomicOp(loc, op, isImage));
              atomic->setLoc(loc);
              atomic->setType(arg2->getType());
              atomic->getWritableType().getQualifier().makeTemporary();
  
              if (isImage) {
                  imageAtomicParams(atomic, arg0);
              } else {
                  atomic->getSequence().push_back(arg0);
              }
  
              atomic->getSequence().push_back(arg1);
              atomic->getSequence().push_back(arg2);
              node = intermediate.addAssign(EOpAssign, arg3, atomic, loc);
  
              break;
          }
  
      case EOpEvaluateAttributeSnapped:
          {
              // SPIR-V InterpolateAtOffset uses float vec2 offset in pixels
              // HLSL uses int2 offset on a 16x16 grid in [-8..7] on x & y:
              //   iU = (iU<<28)>>28
              //   fU = ((float)iU)/16
              // Targets might handle this natively, in which case they can disable
              // decompositions.
  
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();  // value
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();  // offset
  
              TIntermTyped* i28 = intermediate.addConstantUnion(28, loc, true);
              TIntermTyped* iU = handleBinaryMath(loc, ">>", EOpRightShift,
                                                  handleBinaryMath(loc, "<<", EOpLeftShift, arg1, i28),
                                                  i28);
  
              TIntermTyped* recip16 = intermediate.addConstantUnion((1.0/16.0), EbtFloat, loc, true);
              TIntermTyped* floatOffset = handleBinaryMath(loc, "mul", EOpMul,
                                                           intermediate.addConversion(EOpConstructFloat,
                                                                                      TType(EbtFloat, EvqTemporary, 2), iU),
                                                           recip16);
  
              TIntermAggregate* interp = new TIntermAggregate(EOpInterpolateAtOffset);
              interp->getSequence().push_back(arg0);
              interp->getSequence().push_back(floatOffset);
              interp->setLoc(loc);
              interp->setType(arg0->getType());
              interp->getWritableType().getQualifier().makeTemporary();
  
              node = interp;
  
              break;
          }
  
      case EOpLit:
          {
              TIntermTyped* n_dot_l = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* n_dot_h = argAggregate->getSequence()[1]->getAsTyped();
              TIntermTyped* m = argAggregate->getSequence()[2]->getAsTyped();
  
              TIntermAggregate* dst = new TIntermAggregate(EOpConstructVec4);
  
              // Ambient
              dst->getSequence().push_back(intermediate.addConstantUnion(1.0, EbtFloat, loc, true));
  
              // Diffuse:
              TIntermTyped* zero = intermediate.addConstantUnion(0.0, EbtFloat, loc, true);
              TIntermAggregate* diffuse = new TIntermAggregate(EOpMax);
              diffuse->getSequence().push_back(n_dot_l);
              diffuse->getSequence().push_back(zero);
              diffuse->setLoc(loc);
              diffuse->setType(TType(EbtFloat));
              dst->getSequence().push_back(diffuse);
  
              // Specular:
              TIntermAggregate* min_ndot = new TIntermAggregate(EOpMin);
              min_ndot->getSequence().push_back(n_dot_l);
              min_ndot->getSequence().push_back(n_dot_h);
              min_ndot->setLoc(loc);
              min_ndot->setType(TType(EbtFloat));
  
              TIntermTyped* compare = handleBinaryMath(loc, "<", EOpLessThan, min_ndot, zero);
              TIntermTyped* n_dot_h_m = handleBinaryMath(loc, "mul", EOpMul, n_dot_h, m);  // n_dot_h * m
  
              dst->getSequence().push_back(intermediate.addSelection(compare, zero, n_dot_h_m, loc));
  
              // One:
              dst->getSequence().push_back(intermediate.addConstantUnion(1.0, EbtFloat, loc, true));
  
              dst->setLoc(loc);
              dst->setType(TType(EbtFloat, EvqTemporary, 4));
              node = dst;
              break;
          }
  
      case EOpAsDouble:
          {
              // asdouble accepts two 32 bit ints.  we can use EOpUint64BitsToDouble, but must
              // first construct a uint64.
              TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();
              TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();
  
              if (arg0->getType().isVector()) { // TODO: ...
                  error(loc, "double2 conversion not implemented", "asdouble", "");
                  break;
              }
  
              TIntermAggregate* uint64 = new TIntermAggregate(EOpConstructUVec2);
  
              uint64->getSequence().push_back(arg0);
              uint64->getSequence().push_back(arg1);
              uint64->setType(TType(EbtUint, EvqTemporary, 2));  // convert 2 uints to a uint2
              uint64->setLoc(loc);
  
              // bitcast uint2 to a double
              TIntermTyped* convert = new TIntermUnary(EOpUint64BitsToDouble);
              convert->getAsUnaryNode()->setOperand(uint64);
              convert->setLoc(loc);
              convert->setType(TType(EbtDouble, EvqTemporary));
              node = convert;
  
              break;
          }
  
      case EOpF16tof32:
          {
              // input uvecN with low 16 bits of each component holding a float16.  convert to float32.
              TIntermTyped* argValue = node->getAsUnaryNode()->getOperand();
              TIntermTyped* zero = intermediate.addConstantUnion(0, loc, true);
              const int vecSize = argValue->getType().getVectorSize();
  
              TOperator constructOp = EOpNull;
              switch (vecSize) {
              case 1: constructOp = EOpNull;          break; // direct use, no construct needed
              case 2: constructOp = EOpConstructVec2; break;
              case 3: constructOp = EOpConstructVec3; break;
              case 4: constructOp = EOpConstructVec4; break;
              default: assert(0); break;
              }
  
              // For scalar case, we don't need to construct another type.
              TIntermAggregate* result = (vecSize > 1) ? new TIntermAggregate(constructOp) : nullptr;
  
              if (result) {
                  result->setType(TType(EbtFloat, EvqTemporary, vecSize));
                  result->setLoc(loc);
              }
  
              for (int idx = 0; idx < vecSize; ++idx) {
                  TIntermTyped* idxConst = intermediate.addConstantUnion(idx, loc, true);
                  TIntermTyped* component = argValue->getType().isVector() ? 
                      intermediate.addIndex(EOpIndexDirect, argValue, idxConst, loc) : argValue;
  
                  if (component != argValue)
                      component->setType(TType(argValue->getBasicType(), EvqTemporary));
  
                  TIntermTyped* unpackOp  = new TIntermUnary(EOpUnpackHalf2x16);
                  unpackOp->setType(TType(EbtFloat, EvqTemporary, 2));
                  unpackOp->getAsUnaryNode()->setOperand(component);
                  unpackOp->setLoc(loc);
  
                  TIntermTyped* lowOrder  = intermediate.addIndex(EOpIndexDirect, unpackOp, zero, loc);
                  
                  if (result != nullptr) {
                      result->getSequence().push_back(lowOrder);
                      node = result;
                  } else {
                      node = lowOrder;
                  }
              }
              
              break;
          }
  
      case EOpF32tof16:
          {
              // input floatN converted to 16 bit float in low order bits of each component of uintN
              TIntermTyped* argValue = node->getAsUnaryNode()->getOperand();
  
              TIntermTyped* zero = intermediate.addConstantUnion(0.0, EbtFloat, loc, true);
              const int vecSize = argValue->getType().getVectorSize();
  
              TOperator constructOp = EOpNull;
              switch (vecSize) {
              case 1: constructOp = EOpNull;           break; // direct use, no construct needed
              case 2: constructOp = EOpConstructUVec2; break;
              case 3: constructOp = EOpConstructUVec3; break;
              case 4: constructOp = EOpConstructUVec4; break;
              default: assert(0); break;
              }
  
              // For scalar case, we don't need to construct another type.
              TIntermAggregate* result = (vecSize > 1) ? new TIntermAggregate(constructOp) : nullptr;
  
              if (result) {
                  result->setType(TType(EbtUint, EvqTemporary, vecSize));
                  result->setLoc(loc);
              }
  
              for (int idx = 0; idx < vecSize; ++idx) {
                  TIntermTyped* idxConst = intermediate.addConstantUnion(idx, loc, true);
                  TIntermTyped* component = argValue->getType().isVector() ? 
                      intermediate.addIndex(EOpIndexDirect, argValue, idxConst, loc) : argValue;
  
                  if (component != argValue)
                      component->setType(TType(argValue->getBasicType(), EvqTemporary));
  
                  TIntermAggregate* vec2ComponentAndZero = new TIntermAggregate(EOpConstructVec2);
                  vec2ComponentAndZero->getSequence().push_back(component);
                  vec2ComponentAndZero->getSequence().push_back(zero);
                  vec2ComponentAndZero->setType(TType(EbtFloat, EvqTemporary, 2));
                  vec2ComponentAndZero->setLoc(loc);
                  
                  TIntermTyped* packOp = new TIntermUnary(EOpPackHalf2x16);
                  packOp->getAsUnaryNode()->setOperand(vec2ComponentAndZero);
                  packOp->setLoc(loc);
                  packOp->setType(TType(EbtUint, EvqTemporary));
  
                  if (result != nullptr) {
                      result->getSequence().push_back(packOp);
                      node = result;
                  } else {
                      node = packOp;
                  }
              }
  
              break;
          }
  
      case EOpD3DCOLORtoUBYTE4:
          {
              // ivec4 ( x.zyxw * 255.001953 );
              TIntermTyped* arg0 = node->getAsUnaryNode()->getOperand();
              TSwizzleSelectors<TVectorSelector> selectors;
              selectors.push_back(2);
              selectors.push_back(1);
              selectors.push_back(0);
              selectors.push_back(3);
              TIntermTyped* swizzleIdx = intermediate.addSwizzle(selectors, loc);
              TIntermTyped* swizzled = intermediate.addIndex(EOpVectorSwizzle, arg0, swizzleIdx, loc);
              swizzled->setType(arg0->getType());
              swizzled->getWritableType().getQualifier().makeTemporary();
  
              TIntermTyped* conversion = intermediate.addConstantUnion(255.001953f, EbtFloat, loc, true);
              TIntermTyped* rangeConverted = handleBinaryMath(loc, "mul", EOpMul, conversion, swizzled);
              rangeConverted->setType(arg0->getType());
              rangeConverted->getWritableType().getQualifier().makeTemporary();
  
              node = intermediate.addConversion(EOpConstructInt, TType(EbtInt, EvqTemporary, 4), rangeConverted);
              node->setLoc(loc);
              node->setType(TType(EbtInt, EvqTemporary, 4));
              break;
          }
  
      case EOpIsFinite:
          {
              // Since OPIsFinite in SPIR-V is only supported with the Kernel capability, we translate
              // it to !isnan && !isinf
  
              TIntermTyped* arg0 = node->getAsUnaryNode()->getOperand();
  
              // We'll make a temporary in case the RHS is cmoplex
              TVariable* tempArg = makeInternalVariable("@finitetmp", arg0->getType());
              tempArg->getWritableType().getQualifier().makeTemporary();
  
              TIntermTyped* tmpArgAssign = intermediate.addAssign(EOpAssign,
                                                                  intermediate.addSymbol(*tempArg, loc),
                                                                  arg0, loc);
  
              TIntermAggregate* compoundStatement = intermediate.makeAggregate(tmpArgAssign, loc);
  
              const TType boolType(EbtBool, EvqTemporary, arg0->getVectorSize(), arg0->getMatrixCols(),
                                   arg0->getMatrixRows());
  
              TIntermTyped* isnan = handleUnaryMath(loc, "isnan", EOpIsNan, intermediate.addSymbol(*tempArg, loc));
              isnan->setType(boolType);
  
              TIntermTyped* notnan = handleUnaryMath(loc, "!", EOpLogicalNot, isnan);
              notnan->setType(boolType);
  
              TIntermTyped* isinf = handleUnaryMath(loc, "isinf", EOpIsInf, intermediate.addSymbol(*tempArg, loc));
              isinf->setType(boolType);
  
              TIntermTyped* notinf = handleUnaryMath(loc, "!", EOpLogicalNot, isinf);
              notinf->setType(boolType);
              
              TIntermTyped* andNode = handleBinaryMath(loc, "and", EOpLogicalAnd, notnan, notinf);
              andNode->setType(boolType);
  
              compoundStatement = intermediate.growAggregate(compoundStatement, andNode);
              compoundStatement->setOperator(EOpSequence);
              compoundStatement->setLoc(loc);
              compoundStatement->setType(boolType);
  
              node = compoundStatement;
  
              break;
          }
      case EOpWaveGetLaneCount:
          {
              // Mapped to gl_SubgroupSize builtin (We preprend @ to the symbol
              // so that it inhabits the symbol table, but has a user-invalid name
              // in-case some source HLSL defined the symbol also).
              TType type(EbtUint, EvqVaryingIn);
              node = lookupBuiltinVariable("@gl_SubgroupSize", EbvSubgroupSize2, type);
              break;
          }
      case EOpWaveGetLaneIndex:
          {
              // Mapped to gl_SubgroupInvocationID builtin (We preprend @ to the
              // symbol so that it inhabits the symbol table, but has a
              // user-invalid name in-case some source HLSL defined the symbol
              // also).
              TType type(EbtUint, EvqVaryingIn);
              node = lookupBuiltinVariable("@gl_SubgroupInvocationID", EbvSubgroupInvocation2, type);
              break;
          }
      case EOpWaveActiveCountBits:
          {
              // Mapped to subgroupBallotBitCount(subgroupBallot()) builtin
  
              // uvec4 type.
              TType uvec4Type(EbtUint, EvqTemporary, 4);
  
              // Get the uvec4 return from subgroupBallot().
              TIntermTyped* res = intermediate.addBuiltInFunctionCall(loc,
                  EOpSubgroupBallot, true, arguments, uvec4Type);
  
              // uint type.
              TType uintType(EbtUint, EvqTemporary);
  
              node = intermediate.addBuiltInFunctionCall(loc,
                  EOpSubgroupBallotBitCount, true, res, uintType);
  
              break;
          }
      case EOpWavePrefixCountBits:
          {
              // Mapped to subgroupBallotInclusiveBitCount(subgroupBallot())
              // builtin
  
              // uvec4 type.
              TType uvec4Type(EbtUint, EvqTemporary, 4);
  
              // Get the uvec4 return from subgroupBallot().
              TIntermTyped* res = intermediate.addBuiltInFunctionCall(loc,
                  EOpSubgroupBallot, true, arguments, uvec4Type);
  
              // uint type.
              TType uintType(EbtUint, EvqTemporary);
  
              node = intermediate.addBuiltInFunctionCall(loc,
                  EOpSubgroupBallotInclusiveBitCount, true, res, uintType);
  
              break;
          }
  
      default:
          break; // most pass through unchanged
      }
  }
  
  //
  // Handle seeing function call syntax in the grammar, which could be any of
  //  - .length() method
  //  - constructor
  //  - a call to a built-in function mapped to an operator
  //  - a call to a built-in function that will remain a function call (e.g., texturing)
  //  - user function
  //  - subroutine call (not implemented yet)
  //
  TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction* function, TIntermTyped* arguments)
  {
      TIntermTyped* result = nullptr;
  
      TOperator op = function->getBuiltInOp();
      if (op != EOpNull) {
          //
          // Then this should be a constructor.
          // Don't go through the symbol table for constructors.
          // Their parameters will be verified algorithmically.
          //
          TType type(EbtVoid);  // use this to get the type back
          if (! constructorError(loc, arguments, *function, op, type)) {
              //
              // It's a constructor, of type 'type'.
              //
              result = handleConstructor(loc, arguments, type);
              if (result == nullptr) {
                  error(loc, "cannot construct with these arguments", type.getCompleteString().c_str(), "");
                  return nullptr;
              }
          }
      } else {
          //
          // Find it in the symbol table.
          //
          const TFunction* fnCandidate = nullptr;
          bool builtIn = false;
          int thisDepth = 0;
  
          // For mat mul, the situation is unusual: we have to compare vector sizes to mat row or col sizes,
          // and clamp the opposite arg.  Since that's complex, we farm it off to a separate method.
          // It doesn't naturally fall out of processing an argument at a time in isolation.
          if (function->getName() == "mul")
              addGenMulArgumentConversion(loc, *function, arguments);
  
          TIntermAggregate* aggregate = arguments ? arguments->getAsAggregate() : nullptr;
  
          // TODO: this needs improvement: there's no way at present to look up a signature in
          // the symbol table for an arbitrary type.  This is a temporary hack until that ability exists.
          // It will have false positives, since it doesn't check arg counts or types.
          if (arguments) {
              // Check if first argument is struct buffer type.  It may be an aggregate or a symbol, so we
              // look for either case.
  
              TIntermTyped* arg0 = nullptr;
  
              if (aggregate && aggregate->getSequence().size() > 0 && aggregate->getSequence()[0])
                  arg0 = aggregate->getSequence()[0]->getAsTyped();
              else if (arguments->getAsSymbolNode())
                  arg0 = arguments->getAsSymbolNode();
  
              if (arg0 != nullptr && isStructBufferType(arg0->getType())) {
                  static const int methodPrefixSize = sizeof(BUILTIN_PREFIX)-1;
  
                  if (function->getName().length() > methodPrefixSize &&
                      isStructBufferMethod(function->getName().substr(methodPrefixSize))) {
                      const TString mangle = function->getName() + "(";
                      TSymbol* symbol = symbolTable.find(mangle, &builtIn);
  
                      if (symbol)
                          fnCandidate = symbol->getAsFunction();
                  }
              }
          }
  
          if (fnCandidate == nullptr)
              fnCandidate = findFunction(loc, *function, builtIn, thisDepth, arguments);
  
          if (fnCandidate) {
              // This is a declared function that might map to
              //  - a built-in operator,
              //  - a built-in function not mapped to an operator, or
              //  - a user function.
  
              // turn an implicit member-function resolution into an explicit call
              TString callerName;
              if (thisDepth == 0)
                  callerName = fnCandidate->getMangledName();
              else {
                  // get the explicit (full) name of the function
                  callerName = currentTypePrefix[currentTypePrefix.size() - thisDepth];
                  callerName += fnCandidate->getMangledName();
                  // insert the implicit calling argument
                  pushFrontArguments(intermediate.addSymbol(*getImplicitThis(thisDepth)), arguments);
              }
  
              // Convert 'in' arguments, so that types match.
              // However, skip those that need expansion, that is covered next.
              if (arguments)
                  addInputArgumentConversions(*fnCandidate, arguments);
  
              // Expand arguments.  Some arguments must physically expand to a different set
              // than what the shader declared and passes.
              if (arguments && !builtIn)
                  expandArguments(loc, *fnCandidate, arguments);
  
              // Expansion may have changed the form of arguments
              aggregate = arguments ? arguments->getAsAggregate() : nullptr;
  
              op = fnCandidate->getBuiltInOp();
              if (builtIn && op != EOpNull) {
                  // A function call mapped to a built-in operation.
                  result = intermediate.addBuiltInFunctionCall(loc, op, fnCandidate->getParamCount() == 1, arguments,
                                                               fnCandidate->getType());
                  if (result == nullptr)  {
                      error(arguments->getLoc(), " wrong operand type", "Internal Error",
                          "built in unary operator function.  Type: %s",
                          static_cast<TIntermTyped*>(arguments)->getCompleteString().c_str());
                  } else if (result->getAsOperator()) {
                      builtInOpCheck(loc, *fnCandidate, *result->getAsOperator());
                  }
              } else {
                  // This is a function call not mapped to built-in operator.
                  // It could still be a built-in function, but only if PureOperatorBuiltins == false.
                  result = intermediate.setAggregateOperator(arguments, EOpFunctionCall, fnCandidate->getType(), loc);
                  TIntermAggregate* call = result->getAsAggregate();
                  call->setName(callerName);
  
                  // this is how we know whether the given function is a built-in function or a user-defined function
                  // if builtIn == false, it's a userDefined -> could be an overloaded built-in function also
                  // if builtIn == true, it's definitely a built-in function with EOpNull
                  if (! builtIn) {
                      call->setUserDefined();
                      intermediate.addToCallGraph(infoSink, currentCaller, callerName);
                  }
              }
  
              // for decompositions, since we want to operate on the function node, not the aggregate holding
              // output conversions.
              const TIntermTyped* fnNode = result;
  
              decomposeStructBufferMethods(loc, result, arguments); // HLSL->AST struct buffer method decompositions
              decomposeIntrinsic(loc, result, arguments);           // HLSL->AST intrinsic decompositions
              decomposeSampleMethods(loc, result, arguments);       // HLSL->AST sample method decompositions
              decomposeGeometryMethods(loc, result, arguments);     // HLSL->AST geometry method decompositions
  
              // Create the qualifier list, carried in the AST for the call.
              // Because some arguments expand to multiple arguments, the qualifier list will
              // be longer than the formal parameter list.
              if (result == fnNode && result->getAsAggregate()) {
                  TQualifierList& qualifierList = result->getAsAggregate()->getQualifierList();
                  for (int i = 0; i < fnCandidate->getParamCount(); ++i) {
                      TStorageQualifier qual = (*fnCandidate)[i].type->getQualifier().storage;
                      if (hasStructBuffCounter(*(*fnCandidate)[i].type)) {
                          // add buffer and counter buffer argument qualifier
                          qualifierList.push_back(qual);
                          qualifierList.push_back(qual);
                      } else if (shouldFlatten(*(*fnCandidate)[i].type, (*fnCandidate)[i].type->getQualifier().storage,
                                               true)) {
                          // add structure member expansion
                          for (int memb = 0; memb < (int)(*fnCandidate)[i].type->getStruct()->size(); ++memb)
                              qualifierList.push_back(qual);
                      } else {
                          // Normal 1:1 case
                          qualifierList.push_back(qual);
                      }
                  }
              }
  
              // Convert 'out' arguments.  If it was a constant folded built-in, it won't be an aggregate anymore.
              // Built-ins with a single argument aren't called with an aggregate, but they also don't have an output.
              // Also, build the qualifier list for user function calls, which are always called with an aggregate.
              // We don't do this is if there has been a decomposition, which will have added its own conversions
              // for output parameters.
              if (result == fnNode && result->getAsAggregate())
                  result = addOutputArgumentConversions(*fnCandidate, *result->getAsOperator());
          }
      }
  
      // generic error recovery
      // TODO: simplification: localize all the error recoveries that look like this, and taking type into account to
      //       reduce cascades
      if (result == nullptr)
          result = intermediate.addConstantUnion(0.0, EbtFloat, loc);
  
      return result;
  }
  
  // An initial argument list is difficult: it can be null, or a single node,
  // or an aggregate if more than one argument.  Add one to the front, maintaining
  // this lack of uniformity.
  void HlslParseContext::pushFrontArguments(TIntermTyped* front, TIntermTyped*& arguments)
  {
      if (arguments == nullptr)
          arguments = front;
      else if (arguments->getAsAggregate() != nullptr)
          arguments->getAsAggregate()->getSequence().insert(arguments->getAsAggregate()->getSequence().begin(), front);
      else
          arguments = intermediate.growAggregate(front, arguments);
  }
  
  //
  // HLSL allows mismatched dimensions on vec*mat, mat*vec, vec*vec, and mat*mat.  This is a
  // situation not well suited to resolution in intrinsic selection, but we can do so here, since we
  // can look at both arguments insert explicit shape changes if required.
  //
  void HlslParseContext::addGenMulArgumentConversion(const TSourceLoc& loc, TFunction& call, TIntermTyped*& args)
  {
      TIntermAggregate* argAggregate = args ? args->getAsAggregate() : nullptr;
  
      if (argAggregate == nullptr || argAggregate->getSequence().size() != 2) {
          // It really ought to have two arguments.
          error(loc, "expected: mul arguments", "", "");
          return;
      }
  
      TIntermTyped* arg0 = argAggregate->getSequence()[0]->getAsTyped();
      TIntermTyped* arg1 = argAggregate->getSequence()[1]->getAsTyped();
  
      if (arg0->isVector() && arg1->isVector()) {
          // For:
          //    vec * vec: it's handled during intrinsic selection, so while we could do it here,
          //               we can also ignore it, which is easier.
      } else if (arg0->isVector() && arg1->isMatrix()) {
          // vec * mat: we clamp the vec if the mat col is smaller, else clamp the mat col.
          if (arg0->getVectorSize() < arg1->getMatrixCols()) {
              // vec is smaller, so truncate larger mat dimension
              const TType truncType(arg1->getBasicType(), arg1->getQualifier().storage, arg1->getQualifier().precision,
                                    0, arg0->getVectorSize(), arg1->getMatrixRows());
              arg1 = addConstructor(loc, arg1, truncType);
          } else if (arg0->getVectorSize() > arg1->getMatrixCols()) {
              // vec is larger, so truncate vec to mat size
              const TType truncType(arg0->getBasicType(), arg0->getQualifier().storage, arg0->getQualifier().precision,
                                    arg1->getMatrixCols());
              arg0 = addConstructor(loc, arg0, truncType);
          }
      } else if (arg0->isMatrix() && arg1->isVector()) {
          // mat * vec: we clamp the vec if the mat col is smaller, else clamp the mat col.
          if (arg1->getVectorSize() < arg0->getMatrixRows()) {
              // vec is smaller, so truncate larger mat dimension
              const TType truncType(arg0->getBasicType(), arg0->getQualifier().storage, arg0->getQualifier().precision,
                                    0, arg0->getMatrixCols(), arg1->getVectorSize());
              arg0 = addConstructor(loc, arg0, truncType);
          } else if (arg1->getVectorSize() > arg0->getMatrixRows()) {
              // vec is larger, so truncate vec to mat size
              const TType truncType(arg1->getBasicType(), arg1->getQualifier().storage, arg1->getQualifier().precision,
                                    arg0->getMatrixRows());
              arg1 = addConstructor(loc, arg1, truncType);
          }
      } else if (arg0->isMatrix() && arg1->isMatrix()) {
          // mat * mat: we clamp the smaller inner dimension to match the other matrix size.
          // Remember, HLSL Mrc = GLSL/SPIRV Mcr.
          if (arg0->getMatrixRows() > arg1->getMatrixCols()) {
              const TType truncType(arg0->getBasicType(), arg0->getQualifier().storage, arg0->getQualifier().precision,
                                    0, arg0->getMatrixCols(), arg1->getMatrixCols());
              arg0 = addConstructor(loc, arg0, truncType);
          } else if (arg0->getMatrixRows() < arg1->getMatrixCols()) {
              const TType truncType(arg1->getBasicType(), arg1->getQualifier().storage, arg1->getQualifier().precision,
                                    0, arg0->getMatrixRows(), arg1->getMatrixRows());
              arg1 = addConstructor(loc, arg1, truncType);
          }
      } else {
          // It's something with scalars: we'll just leave it alone.  Function selection will handle it
          // downstream.
      }
  
      // Warn if we altered one of the arguments
      if (arg0 != argAggregate->getSequence()[0] || arg1 != argAggregate->getSequence()[1])
          warn(loc, "mul() matrix size mismatch", "", "");
  
      // Put arguments back.  (They might be unchanged, in which case this is harmless).
      argAggregate->getSequence()[0] = arg0;
      argAggregate->getSequence()[1] = arg1;
  
      call[0].type = &arg0->getWritableType();
      call[1].type = &arg1->getWritableType();
  }
  
  //
  // Add any needed implicit conversions for function-call arguments to input parameters.
  //
  void HlslParseContext::addInputArgumentConversions(const TFunction& function, TIntermTyped*& arguments)
  {
      TIntermAggregate* aggregate = arguments->getAsAggregate();
  
      // Replace a single argument with a single argument.
      const auto setArg = [&](int paramNum, TIntermTyped* arg) {
          if (function.getParamCount() == 1)
              arguments = arg;
          else {
              if (aggregate == nullptr)
                  arguments = arg;
              else
                  aggregate->getSequence()[paramNum] = arg;
          }
      };
  
      // Process each argument's conversion
      for (int param = 0; param < function.getParamCount(); ++param) {
          if (! function[param].type->getQualifier().isParamInput())
              continue;
  
          // At this early point there is a slight ambiguity between whether an aggregate 'arguments'
          // is the single argument itself or its children are the arguments.  Only one argument
          // means take 'arguments' itself as the one argument.
          TIntermTyped* arg = function.getParamCount() == 1
                                     ? arguments->getAsTyped()
                                     : (aggregate ? 
                                          aggregate->getSequence()[param]->getAsTyped() :
                                          arguments->getAsTyped());
          if (*function[param].type != arg->getType()) {
              // In-qualified arguments just need an extra node added above the argument to
              // convert to the correct type.
              TIntermTyped* convArg = intermediate.addConversion(EOpFunctionCall, *function[param].type, arg);
              if (convArg != nullptr)
                  convArg = intermediate.addUniShapeConversion(EOpFunctionCall, *function[param].type, convArg);
              if (convArg != nullptr)
                  setArg(param, convArg);
              else
                  error(arg->getLoc(), "cannot convert input argument, argument", "", "%d", param);
          } else {
              if (wasFlattened(arg)) {
                  // If both formal and calling arg are to be flattened, leave that to argument
                  // expansion, not conversion.
                  if (!shouldFlatten(*function[param].type, function[param].type->getQualifier().storage, true)) {
                      // Will make a two-level subtree.
                      // The deepest will copy member-by-member to build the structure to pass.
                      // The level above that will be a two-operand EOpComma sequence that follows the copy by the
                      // object itself.
                      TVariable* internalAggregate = makeInternalVariable("aggShadow", *function[param].type);
                      internalAggregate->getWritableType().getQualifier().makeTemporary();
                      TIntermSymbol* internalSymbolNode = new TIntermSymbol(internalAggregate->getUniqueId(),
                                                                            internalAggregate->getName(),
                                                                            internalAggregate->getType());
                      internalSymbolNode->setLoc(arg->getLoc());
                      // This makes the deepest level, the member-wise copy
                      TIntermAggregate* assignAgg = handleAssign(arg->getLoc(), EOpAssign,
                                                                 internalSymbolNode, arg)->getAsAggregate();
  
                      // Now, pair that with the resulting aggregate.
                      assignAgg = intermediate.growAggregate(assignAgg, internalSymbolNode, arg->getLoc());
                      assignAgg->setOperator(EOpComma);
                      assignAgg->setType(internalAggregate->getType());
                      setArg(param, assignAgg);
                  }
              }
          }
      }
  }
  
  //
  // Add any needed implicit expansion of calling arguments from what the shader listed to what's
  // internally needed for the AST (given the constraints downstream).
  //
  void HlslParseContext::expandArguments(const TSourceLoc& loc, const TFunction& function, TIntermTyped*& arguments)
  {
      TIntermAggregate* aggregate = arguments->getAsAggregate();
      int functionParamNumberOffset = 0;
  
      // Replace a single argument with a single argument.
      const auto setArg = [&](int paramNum, TIntermTyped* arg) {
          if (function.getParamCount() + functionParamNumberOffset == 1)
              arguments = arg;
          else {
              if (aggregate == nullptr)
                  arguments = arg;
              else
                  aggregate->getSequence()[paramNum] = arg;
          }
      };
  
      // Replace a single argument with a list of arguments
      const auto setArgList = [&](int paramNum, const TVector<TIntermTyped*>& args) {
          if (args.size() == 1)
              setArg(paramNum, args.front());
          else if (args.size() > 1) {
              if (function.getParamCount() + functionParamNumberOffset == 1) {
                  arguments = intermediate.makeAggregate(args.front());
                  std::for_each(args.begin() + 1, args.end(), 
                      [&](TIntermTyped* arg) {
                          arguments = intermediate.growAggregate(arguments, arg);
                      });
              } else {
                  auto it = aggregate->getSequence().erase(aggregate->getSequence().begin() + paramNum);
                  aggregate->getSequence().insert(it, args.begin(), args.end());
              }
              functionParamNumberOffset += (int)(args.size() - 1);
          }
      };
  
      // Process each argument's conversion
      for (int param = 0; param < function.getParamCount(); ++param) {
          // At this early point there is a slight ambiguity between whether an aggregate 'arguments'
          // is the single argument itself or its children are the arguments.  Only one argument
          // means take 'arguments' itself as the one argument.
          TIntermTyped* arg = function.getParamCount() == 1
                                     ? arguments->getAsTyped()
                                     : (aggregate ? 
                                          aggregate->getSequence()[param + functionParamNumberOffset]->getAsTyped() :
                                          arguments->getAsTyped());
  
          if (wasFlattened(arg) && shouldFlatten(*function[param].type, function[param].type->getQualifier().storage, true)) {
              // Need to pass the structure members instead of the structure.
              TVector<TIntermTyped*> memberArgs;
              for (int memb = 0; memb < (int)arg->getType().getStruct()->size(); ++memb)
                  memberArgs.push_back(flattenAccess(arg, memb));
              setArgList(param + functionParamNumberOffset, memberArgs);
          }
      }
  
      // TODO: if we need both hidden counter args (below) and struct expansion (above)
      // the two algorithms need to be merged: Each assumes the list starts out 1:1 between
      // parameters and arguments.
  
      // If any argument is a pass-by-reference struct buffer with an associated counter
      // buffer, we have to add another hidden parameter for that counter.
      if (aggregate)
          addStructBuffArguments(loc, aggregate);
  }
  
  //
  // Add any needed implicit output conversions for function-call arguments.  This
  // can require a new tree topology, complicated further by whether the function
  // has a return value.
  //
  // Returns a node of a subtree that evaluates to the return value of the function.
  //
  TIntermTyped* HlslParseContext::addOutputArgumentConversions(const TFunction& function, TIntermOperator& intermNode)
  {
      assert (intermNode.getAsAggregate() != nullptr || intermNode.getAsUnaryNode() != nullptr);
  
      const TSourceLoc& loc = intermNode.getLoc();
  
      TIntermSequence argSequence; // temp sequence for unary node args
  
      if (intermNode.getAsUnaryNode())
          argSequence.push_back(intermNode.getAsUnaryNode()->getOperand());
  
      TIntermSequence& arguments = argSequence.empty() ? intermNode.getAsAggregate()->getSequence() : argSequence;
  
      const auto needsConversion = [&](int argNum) {
          return function[argNum].type->getQualifier().isParamOutput() &&
                 (*function[argNum].type != arguments[argNum]->getAsTyped()->getType() ||
                  shouldConvertLValue(arguments[argNum]) ||
                  wasFlattened(arguments[argNum]->getAsTyped()));
      };
  
      // Will there be any output conversions?
      bool outputConversions = false;
      for (int i = 0; i < function.getParamCount(); ++i) {
          if (needsConversion(i)) {
              outputConversions = true;
              break;
          }
      }
  
      if (! outputConversions)
          return &intermNode;
  
      // Setup for the new tree, if needed:
      //
      // Output conversions need a different tree topology.
      // Out-qualified arguments need a temporary of the correct type, with the call
      // followed by an assignment of the temporary to the original argument:
      //     void: function(arg, ...)  ->        (          function(tempArg, ...), arg = tempArg, ...)
      //     ret = function(arg, ...)  ->  ret = (tempRet = function(tempArg, ...), arg = tempArg, ..., tempRet)
      // Where the "tempArg" type needs no conversion as an argument, but will convert on assignment.
      TIntermTyped* conversionTree = nullptr;
      TVariable* tempRet = nullptr;
      if (intermNode.getBasicType() != EbtVoid) {
          // do the "tempRet = function(...), " bit from above
          tempRet = makeInternalVariable("tempReturn", intermNode.getType());
          TIntermSymbol* tempRetNode = intermediate.addSymbol(*tempRet, loc);
          conversionTree = intermediate.addAssign(EOpAssign, tempRetNode, &intermNode, loc);
      } else
          conversionTree = &intermNode;
  
      conversionTree = intermediate.makeAggregate(conversionTree);
  
      // Process each argument's conversion
      for (int i = 0; i < function.getParamCount(); ++i) {
          if (needsConversion(i)) {
              // Out-qualified arguments needing conversion need to use the topology setup above.
              // Do the " ...(tempArg, ...), arg = tempArg" bit from above.
  
              // Make a temporary for what the function expects the argument to look like.
              TVariable* tempArg = makeInternalVariable("tempArg", *function[i].type);
              tempArg->getWritableType().getQualifier().makeTemporary();
              TIntermSymbol* tempArgNode = intermediate.addSymbol(*tempArg, loc);
  
              // This makes the deepest level, the member-wise copy
              TIntermTyped* tempAssign = handleAssign(arguments[i]->getLoc(), EOpAssign, arguments[i]->getAsTyped(),
                                                      tempArgNode);
              tempAssign = handleLvalue(arguments[i]->getLoc(), "assign", tempAssign);
              conversionTree = intermediate.growAggregate(conversionTree, tempAssign, arguments[i]->getLoc());
  
              // replace the argument with another node for the same tempArg variable
              arguments[i] = intermediate.addSymbol(*tempArg, loc);
          }
      }
  
      // Finalize the tree topology (see bigger comment above).
      if (tempRet) {
          // do the "..., tempRet" bit from above
          TIntermSymbol* tempRetNode = intermediate.addSymbol(*tempRet, loc);
          conversionTree = intermediate.growAggregate(conversionTree, tempRetNode, loc);
      }
  
      conversionTree = intermediate.setAggregateOperator(conversionTree, EOpComma, intermNode.getType(), loc);
  
      return conversionTree;
  }
  
  //
  // Add any needed "hidden" counter buffer arguments for function calls.
  //
  // Modifies the 'aggregate' argument if needed.  Otherwise, is no-op.
  //
  void HlslParseContext::addStructBuffArguments(const TSourceLoc& loc, TIntermAggregate*& aggregate)
  {
      // See if there are any SB types with counters.
      const bool hasStructBuffArg =
          std::any_of(aggregate->getSequence().begin(),
                      aggregate->getSequence().end(),
                      [this](const TIntermNode* node) {
                          return (node && node->getAsTyped() != nullptr) && hasStructBuffCounter(node->getAsTyped()->getType());
                      });
  
      // Nothing to do, if we didn't find one.
      if (! hasStructBuffArg)
          return;
  
      TIntermSequence argsWithCounterBuffers;
  
      for (int param = 0; param < int(aggregate->getSequence().size()); ++param) {
          argsWithCounterBuffers.push_back(aggregate->getSequence()[param]);
  
          if (hasStructBuffCounter(aggregate->getSequence()[param]->getAsTyped()->getType())) {
              const TIntermSymbol* blockSym = aggregate->getSequence()[param]->getAsSymbolNode();
              if (blockSym != nullptr) {
                  TType counterType;
                  counterBufferType(loc, counterType);
  
                  const TString counterBlockName(intermediate.addCounterBufferName(blockSym->getName()));
  
                  TVariable* variable = makeInternalVariable(counterBlockName, counterType);
  
                  // Mark this buffer's counter block as being in use
                  structBufferCounter[counterBlockName] = true;
  
                  TIntermSymbol* sym = intermediate.addSymbol(*variable, loc);
                  argsWithCounterBuffers.push_back(sym);
              }
          }
      }
  
      // Swap with the temp list we've built up.
      aggregate->getSequence().swap(argsWithCounterBuffers);
  }
  
  
  //
  // Do additional checking of built-in function calls that is not caught
  // by normal semantic checks on argument type, extension tagging, etc.
  //
  // Assumes there has been a semantically correct match to a built-in function prototype.
  //
  void HlslParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCandidate, TIntermOperator& callNode)
  {
      // Set up convenience accessors to the argument(s).  There is almost always
      // multiple arguments for the cases below, but when there might be one,
      // check the unaryArg first.
      const TIntermSequence* argp = nullptr;   // confusing to use [] syntax on a pointer, so this is to help get a reference
      const TIntermTyped* unaryArg = nullptr;
      const TIntermTyped* arg0 = nullptr;
      if (callNode.getAsAggregate()) {
          argp = &callNode.getAsAggregate()->getSequence();
          if (argp->size() > 0)
              arg0 = (*argp)[0]->getAsTyped();
      } else {
          assert(callNode.getAsUnaryNode());
          unaryArg = callNode.getAsUnaryNode()->getOperand();
          arg0 = unaryArg;
      }
      const TIntermSequence& aggArgs = *argp;  // only valid when unaryArg is nullptr
  
      switch (callNode.getOp()) {
      case EOpTextureGather:
      case EOpTextureGatherOffset:
      case EOpTextureGatherOffsets:
      {
          // Figure out which variants are allowed by what extensions,
          // and what arguments must be constant for which situations.
  
          TString featureString = fnCandidate.getName() + "(...)";
          const char* feature = featureString.c_str();
          int compArg = -1;  // track which argument, if any, is the constant component argument
          switch (callNode.getOp()) {
          case EOpTextureGather:
              // More than two arguments needs gpu_shader5, and rectangular or shadow needs gpu_shader5,
              // otherwise, need GL_ARB_texture_gather.
              if (fnCandidate.getParamCount() > 2 || fnCandidate[0].type->getSampler().dim == EsdRect ||
                  fnCandidate[0].type->getSampler().shadow) {
                  if (! fnCandidate[0].type->getSampler().shadow)
                      compArg = 2;
              }
              break;
          case EOpTextureGatherOffset:
              // GL_ARB_texture_gather is good enough for 2D non-shadow textures with no component argument
              if (! fnCandidate[0].type->getSampler().shadow)
                  compArg = 3;
              break;
          case EOpTextureGatherOffsets:
              if (! fnCandidate[0].type->getSampler().shadow)
                  compArg = 3;
              break;
          default:
              break;
          }
  
          if (compArg > 0 && compArg < fnCandidate.getParamCount()) {
              if (aggArgs[compArg]->getAsConstantUnion()) {
                  int value = aggArgs[compArg]->getAsConstantUnion()->getConstArray()[0].getIConst();
                  if (value < 0 || value > 3)
                      error(loc, "must be 0, 1, 2, or 3:", feature, "component argument");
              } else
                  error(loc, "must be a compile-time constant:", feature, "component argument");
          }
  
          break;
      }
  
      case EOpTextureOffset:
      case EOpTextureFetchOffset:
      case EOpTextureProjOffset:
      case EOpTextureLodOffset:
      case EOpTextureProjLodOffset:
      case EOpTextureGradOffset:
      case EOpTextureProjGradOffset:
      {
          // Handle texture-offset limits checking
          // Pick which argument has to hold constant offsets
          int arg = -1;
          switch (callNode.getOp()) {
          case EOpTextureOffset:          arg = 2;  break;
          case EOpTextureFetchOffset:     arg = (arg0->getType().getSampler().dim != EsdRect) ? 3 : 2; break;
          case EOpTextureProjOffset:      arg = 2;  break;
          case EOpTextureLodOffset:       arg = 3;  break;
          case EOpTextureProjLodOffset:   arg = 3;  break;
          case EOpTextureGradOffset:      arg = 4;  break;
          case EOpTextureProjGradOffset:  arg = 4;  break;
          default:
              assert(0);
              break;
          }
  
          if (arg > 0) {
              if (aggArgs[arg]->getAsConstantUnion() == nullptr)
                  error(loc, "argument must be compile-time constant", "texel offset", "");
              else {
                  const TType& type = aggArgs[arg]->getAsTyped()->getType();
                  for (int c = 0; c < type.getVectorSize(); ++c) {
                      int offset = aggArgs[arg]->getAsConstantUnion()->getConstArray()[c].getIConst();
                      if (offset > resources.maxProgramTexelOffset || offset < resources.minProgramTexelOffset)
                          error(loc, "value is out of range:", "texel offset",
                                "[gl_MinProgramTexelOffset, gl_MaxProgramTexelOffset]");
                  }
              }
          }
  
          break;
      }
  
      case EOpTextureQuerySamples:
      case EOpImageQuerySamples:
          break;
  
      case EOpImageAtomicAdd:
      case EOpImageAtomicMin:
      case EOpImageAtomicMax:
      case EOpImageAtomicAnd:
      case EOpImageAtomicOr:
      case EOpImageAtomicXor:
      case EOpImageAtomicExchange:
      case EOpImageAtomicCompSwap:
          break;
  
      case EOpInterpolateAtCentroid:
      case EOpInterpolateAtSample:
      case EOpInterpolateAtOffset:
          // Make sure the first argument is an interpolant, or an array element of an interpolant
          if (arg0->getType().getQualifier().storage != EvqVaryingIn) {
              // It might still be an array element.
              //
              // We could check more, but the semantics of the first argument are already met; the
              // only way to turn an array into a float/vec* is array dereference and swizzle.
              //
              // ES and desktop 4.3 and earlier:  swizzles may not be used
              // desktop 4.4 and later: swizzles may be used
              const TIntermTyped* base = TIntermediate::findLValueBase(arg0, true);
              if (base == nullptr || base->getType().getQualifier().storage != EvqVaryingIn)
                  error(loc, "first argument must be an interpolant, or interpolant-array element",
                        fnCandidate.getName().c_str(), "");
          }
          break;
  
      default:
          break;
      }
  }
  
  //
  // Handle seeing something in a grammar production that can be done by calling
  // a constructor.
  //
  // The constructor still must be "handled" by handleFunctionCall(), which will
  // then call handleConstructor().
  //
  TFunction* HlslParseContext::makeConstructorCall(const TSourceLoc& loc, const TType& type)
  {
      TOperator op = intermediate.mapTypeToConstructorOp(type);
  
      if (op == EOpNull) {
          error(loc, "cannot construct this type", type.getBasicString(), "");
          return nullptr;
      }
  
      TString empty("");
  
      return new TFunction(&empty, type, op);
  }
  
  //
  // Handle seeing a "COLON semantic" at the end of a type declaration,
  // by updating the type according to the semantic.
  //
  void HlslParseContext::handleSemantic(TSourceLoc loc, TQualifier& qualifier, TBuiltInVariable builtIn,
                                        const TString& upperCase)
  {
      // Parse and return semantic number.  If limit is 0, it will be ignored.  Otherwise, if the parsed
      // semantic number is >= limit, errorMsg is issued and 0 is returned.
      // TODO: it would be nicer if limit and errorMsg had default parameters, but some compilers don't yet
      // accept those in lambda functions.
      const auto getSemanticNumber = [this, loc](const TString& semantic, unsigned int limit, const char* errorMsg) -> unsigned int {
          size_t pos = semantic.find_last_not_of("0123456789");
          if (pos == std::string::npos)
              return 0u;
  
          unsigned int semanticNum = (unsigned int)atoi(semantic.c_str() + pos + 1);
  
          if (limit != 0 && semanticNum >= limit) {
              error(loc, errorMsg, semantic.c_str(), "");
              return 0u;
          }
  
          return semanticNum;
      };
  
      switch(builtIn) {
      case EbvNone:
          // Get location numbers from fragment outputs, instead of
          // auto-assigning them.
          if (language == EShLangFragment && upperCase.compare(0, 9, "SV_TARGET") == 0) {
              qualifier.layoutLocation = getSemanticNumber(upperCase, 0, nullptr);
              nextOutLocation = std::max(nextOutLocation, qualifier.layoutLocation + 1u);
          } else if (upperCase.compare(0, 15, "SV_CLIPDISTANCE") == 0) {
              builtIn = EbvClipDistance;
              qualifier.layoutLocation = getSemanticNumber(upperCase, maxClipCullRegs, "invalid clip semantic");
          } else if (upperCase.compare(0, 15, "SV_CULLDISTANCE") == 0) {
              builtIn = EbvCullDistance;
              qualifier.layoutLocation = getSemanticNumber(upperCase, maxClipCullRegs, "invalid cull semantic");
          }
          break;
      case EbvPosition:
          // adjust for stage in/out
          if (language == EShLangFragment)
              builtIn = EbvFragCoord;
          break;
      case EbvFragStencilRef:
          error(loc, "unimplemented; need ARB_shader_stencil_export", "SV_STENCILREF", "");
          break;
      case EbvTessLevelInner:
      case EbvTessLevelOuter:
          qualifier.patch = true;
          break;
      default:
          break;
      }
  
      if (qualifier.builtIn == EbvNone)
          qualifier.builtIn = builtIn;
      qualifier.semanticName = intermediate.addSemanticName(upperCase);
  }
  
  //
  // Handle seeing something like "PACKOFFSET LEFT_PAREN c[Subcomponent][.component] RIGHT_PAREN"
  //
  // 'location' has the "c[Subcomponent]" part.
  // 'component' points to the "component" part, or nullptr if not present.
  //
  void HlslParseContext::handlePackOffset(const TSourceLoc& loc, TQualifier& qualifier, const glslang::TString& location,
                                          const glslang::TString* component)
  {
      if (location.size() == 0 || location[0] != 'c') {
          error(loc, "expected 'c'", "packoffset", "");
          return;
      }
      if (location.size() == 1)
          return;
      if (! isdigit(location[1])) {
          error(loc, "expected number after 'c'", "packoffset", "");
          return;
      }
  
      qualifier.layoutOffset = 16 * atoi(location.substr(1, location.size()).c_str());
      if (component != nullptr) {
          int componentOffset = 0;
          switch ((*component)[0]) {
          case 'x': componentOffset =  0; break;
          case 'y': componentOffset =  4; break;
          case 'z': componentOffset =  8; break;
          case 'w': componentOffset = 12; break;
          default:
              componentOffset = -1;
              break;
          }
          if (componentOffset < 0 || component->size() > 1) {
              error(loc, "expected {x, y, z, w} for component", "packoffset", "");
              return;
          }
          qualifier.layoutOffset += componentOffset;
      }
  }
  
  //
  // Handle seeing something like "REGISTER LEFT_PAREN [shader_profile,] Type# RIGHT_PAREN"
  //
  // 'profile' points to the shader_profile part, or nullptr if not present.
  // 'desc' is the type# part.
  //
  void HlslParseContext::handleRegister(const TSourceLoc& loc, TQualifier& qualifier, const glslang::TString* profile,
                                        const glslang::TString& desc, int subComponent, const glslang::TString* spaceDesc)
  {
      if (profile != nullptr)
          warn(loc, "ignoring shader_profile", "register", "");
  
      if (desc.size() < 1) {
          error(loc, "expected register type", "register", "");
          return;
      }
  
      int regNumber = 0;
      if (desc.size() > 1) {
          if (isdigit(desc[1]))
              regNumber = atoi(desc.substr(1, desc.size()).c_str());
          else {
              error(loc, "expected register number after register type", "register", "");
              return;
          }
      }
  
      // more information about register types see
      // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-variable-register
      const std::vector<std::string>& resourceInfo = intermediate.getResourceSetBinding();
      switch (std::tolower(desc[0])) {
      case 'c':
          // c register is the register slot in the global const buffer
          // each slot is a vector of 4 32 bit components
          qualifier.layoutOffset = regNumber * 4 * 4;
          break;
          // const buffer register slot
      case 'b':
          // textrues and structured buffers
      case 't':
          // samplers
      case 's':
          // uav resources
      case 'u':
          // if nothing else has set the binding, do so now
          // (other mechanisms override this one)
          if (!qualifier.hasBinding())
              qualifier.layoutBinding = regNumber + subComponent;
  
          // This handles per-register layout sets numbers.  For the global mode which sets
          // every symbol to the same value, see setLinkageLayoutSets().
          if ((resourceInfo.size() % 3) == 0) {
              // Apply per-symbol resource set and binding.
              for (auto it = resourceInfo.cbegin(); it != resourceInfo.cend(); it = it + 3) {
                  if (strcmp(desc.c_str(), it[0].c_str()) == 0) {
                      qualifier.layoutSet = atoi(it[1].c_str());
                      qualifier.layoutBinding = atoi(it[2].c_str()) + subComponent;
                      break;
                  }
              }
          }
          break;
      default:
          warn(loc, "ignoring unrecognized register type", "register", "%c", desc[0]);
          break;
      }
  
      // space
      unsigned int setNumber;
      const auto crackSpace = [&]() -> bool {
          const int spaceLen = 5;
          if (spaceDesc->size() < spaceLen + 1)
              return false;
          if (spaceDesc->compare(0, spaceLen, "space") != 0)
              return false;
          if (! isdigit((*spaceDesc)[spaceLen]))
              return false;
          setNumber = atoi(spaceDesc->substr(spaceLen, spaceDesc->size()).c_str());
          return true;
      };
  
      // if nothing else has set the set, do so now
      // (other mechanisms override this one)
      if (spaceDesc && !qualifier.hasSet()) {
          if (! crackSpace()) {
              error(loc, "expected spaceN", "register", "");
              return;
          }
          qualifier.layoutSet = setNumber;
      }
  }
  
  // Convert to a scalar boolean, or if not allowed by HLSL semantics,
  // report an error and return nullptr.
  TIntermTyped* HlslParseContext::convertConditionalExpression(const TSourceLoc& loc, TIntermTyped* condition,
                                                               bool mustBeScalar)
  {
      if (mustBeScalar && !condition->getType().isScalarOrVec1()) {
          error(loc, "requires a scalar", "conditional expression", "");
          return nullptr;
      }
  
      return intermediate.addConversion(EOpConstructBool, TType(EbtBool, EvqTemporary, condition->getVectorSize()),
                                        condition);
  }
  
  //
  // Same error message for all places assignments don't work.
  //
  void HlslParseContext::assignError(const TSourceLoc& loc, const char* op, TString left, TString right)
  {
      error(loc, "", op, "cannot convert from '%s' to '%s'",
          right.c_str(), left.c_str());
  }
  
  //
  // Same error message for all places unary operations don't work.
  //
  void HlslParseContext::unaryOpError(const TSourceLoc& loc, const char* op, TString operand)
  {
      error(loc, " wrong operand type", op,
          "no operation '%s' exists that takes an operand of type %s (or there is no acceptable conversion)",
          op, operand.c_str());
  }
  
  //
  // Same error message for all binary operations don't work.
  //
  void HlslParseContext::binaryOpError(const TSourceLoc& loc, const char* op, TString left, TString right)
  {
      error(loc, " wrong operand types:", op,
          "no operation '%s' exists that takes a left-hand operand of type '%s' and "
          "a right operand of type '%s' (or there is no acceptable conversion)",
          op, left.c_str(), right.c_str());
  }
  
  //
  // A basic type of EbtVoid is a key that the name string was seen in the source, but
  // it was not found as a variable in the symbol table.  If so, give the error
  // message and insert a dummy variable in the symbol table to prevent future errors.
  //
  void HlslParseContext::variableCheck(TIntermTyped*& nodePtr)
  {
      TIntermSymbol* symbol = nodePtr->getAsSymbolNode();
      if (! symbol)
          return;
  
      if (symbol->getType().getBasicType() == EbtVoid) {
          error(symbol->getLoc(), "undeclared identifier", symbol->getName().c_str(), "");
  
          // Add to symbol table to prevent future error messages on the same name
          if (symbol->getName().size() > 0) {
              TVariable* fakeVariable = new TVariable(&symbol->getName(), TType(EbtFloat));
              symbolTable.insert(*fakeVariable);
  
              // substitute a symbol node for this new variable
              nodePtr = intermediate.addSymbol(*fakeVariable, symbol->getLoc());
          }
      }
  }
  
  //
  // Both test, and if necessary spit out an error, to see if the node is really
  // a constant.
  //
  void HlslParseContext::constantValueCheck(TIntermTyped* node, const char* token)
  {
      if (node->getQualifier().storage != EvqConst)
          error(node->getLoc(), "constant expression required", token, "");
  }
  
  //
  // Both test, and if necessary spit out an error, to see if the node is really
  // an integer.
  //
  void HlslParseContext::integerCheck(const TIntermTyped* node, const char* token)
  {
      if ((node->getBasicType() == EbtInt || node->getBasicType() == EbtUint) && node->isScalar())
          return;
  
      error(node->getLoc(), "scalar integer expression required", token, "");
  }
  
  //
  // Both test, and if necessary spit out an error, to see if we are currently
  // globally scoped.
  //
  void HlslParseContext::globalCheck(const TSourceLoc& loc, const char* token)
  {
      if (! symbolTable.atGlobalLevel())
          error(loc, "not allowed in nested scope", token, "");
  }
  
  bool HlslParseContext::builtInName(const TString& /*identifier*/)
  {
      return false;
  }
  
  //
  // Make sure there is enough data and not too many arguments provided to the
  // constructor to build something of the type of the constructor.  Also returns
  // the type of the constructor.
  //
  // Returns true if there was an error in construction.
  //
  bool HlslParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, TFunction& function,
                                          TOperator op, TType& type)
  {
      type.shallowCopy(function.getType());
  
      bool constructingMatrix = false;
      switch (op) {
      case EOpConstructTextureSampler:
          error(loc, "unhandled texture constructor", "constructor", "");
          return true;
      case EOpConstructMat2x2:
      case EOpConstructMat2x3:
      case EOpConstructMat2x4:
      case EOpConstructMat3x2:
      case EOpConstructMat3x3:
      case EOpConstructMat3x4:
      case EOpConstructMat4x2:
      case EOpConstructMat4x3:
      case EOpConstructMat4x4:
      case EOpConstructDMat2x2:
      case EOpConstructDMat2x3:
      case EOpConstructDMat2x4:
      case EOpConstructDMat3x2:
      case EOpConstructDMat3x3:
      case EOpConstructDMat3x4:
      case EOpConstructDMat4x2:
      case EOpConstructDMat4x3:
      case EOpConstructDMat4x4:
      case EOpConstructIMat2x2:
      case EOpConstructIMat2x3:
      case EOpConstructIMat2x4:
      case EOpConstructIMat3x2:
      case EOpConstructIMat3x3:
      case EOpConstructIMat3x4:
      case EOpConstructIMat4x2:
      case EOpConstructIMat4x3:
      case EOpConstructIMat4x4:
      case EOpConstructUMat2x2:
      case EOpConstructUMat2x3:
      case EOpConstructUMat2x4:
      case EOpConstructUMat3x2:
      case EOpConstructUMat3x3:
      case EOpConstructUMat3x4:
      case EOpConstructUMat4x2:
      case EOpConstructUMat4x3:
      case EOpConstructUMat4x4:
      case EOpConstructBMat2x2:
      case EOpConstructBMat2x3:
      case EOpConstructBMat2x4:
      case EOpConstructBMat3x2:
      case EOpConstructBMat3x3:
      case EOpConstructBMat3x4:
      case EOpConstructBMat4x2:
      case EOpConstructBMat4x3:
      case EOpConstructBMat4x4:
          constructingMatrix = true;
          break;
      default:
          break;
      }
  
      //
      // Walk the arguments for first-pass checks and collection of information.
      //
  
      int size = 0;
      bool constType = true;
      bool full = false;
      bool overFull = false;
      bool matrixInMatrix = false;
      bool arrayArg = false;
      for (int arg = 0; arg < function.getParamCount(); ++arg) {
          if (function[arg].type->isArray()) {
              if (function[arg].type->isUnsizedArray()) {
                  // Can't construct from an unsized array.
                  error(loc, "array argument must be sized", "constructor", "");
                  return true;
              }
              arrayArg = true;
          }
          if (constructingMatrix && function[arg].type->isMatrix())
              matrixInMatrix = true;
  
          // 'full' will go to true when enough args have been seen.  If we loop
          // again, there is an extra argument.
          if (full) {
              // For vectors and matrices, it's okay to have too many components
              // available, but not okay to have unused arguments.
              overFull = true;
          }
  
          size += function[arg].type->computeNumComponents();
          if (op != EOpConstructStruct && ! type.isArray() && size >= type.computeNumComponents())
              full = true;
  
          if (function[arg].type->getQualifier().storage != EvqConst)
              constType = false;
      }
  
      if (constType)
          type.getQualifier().storage = EvqConst;
  
      if (type.isArray()) {
          if (function.getParamCount() == 0) {
              error(loc, "array constructor must have at least one argument", "constructor", "");
              return true;
          }
  
          if (type.isUnsizedArray()) {
              // auto adapt the constructor type to the number of arguments
              type.changeOuterArraySize(function.getParamCount());
          } else if (type.getOuterArraySize() != function.getParamCount() && type.computeNumComponents() > size) {
              error(loc, "array constructor needs one argument per array element", "constructor", "");
              return true;
          }
  
          if (type.isArrayOfArrays()) {
              // Types have to match, but we're still making the type.
              // Finish making the type, and the comparison is done later
              // when checking for conversion.
              TArraySizes& arraySizes = *type.getArraySizes();
  
              // At least the dimensionalities have to match.
              if (! function[0].type->isArray() ||
                  arraySizes.getNumDims() != function[0].type->getArraySizes()->getNumDims() + 1) {
                  error(loc, "array constructor argument not correct type to construct array element", "constructor", "");
                  return true;
              }
  
              if (arraySizes.isInnerUnsized()) {
                  // "Arrays of arrays ..., and the size for any dimension is optional"
                  // That means we need to adopt (from the first argument) the other array sizes into the type.
                  for (int d = 1; d < arraySizes.getNumDims(); ++d) {
                      if (arraySizes.getDimSize(d) == UnsizedArraySize) {
                          arraySizes.setDimSize(d, function[0].type->getArraySizes()->getDimSize(d - 1));
                      }
                  }
              }
          }
      }
  
      // Some array -> array type casts are okay
      if (arrayArg && function.getParamCount() == 1 && op != EOpConstructStruct && type.isArray() &&
          !type.isArrayOfArrays() && !function[0].type->isArrayOfArrays() &&
          type.getVectorSize() >= 1 && function[0].type->getVectorSize() >= 1)
          return false;
  
      if (arrayArg && op != EOpConstructStruct && ! type.isArrayOfArrays()) {
          error(loc, "constructing non-array constituent from array argument", "constructor", "");
          return true;
      }
  
      if (matrixInMatrix && ! type.isArray()) {
          return false;
      }
  
      if (overFull) {
          error(loc, "too many arguments", "constructor", "");
          return true;
      }
  
      if (op == EOpConstructStruct && ! type.isArray()) {
          if (isScalarConstructor(node))
              return false;
  
          // Self-type construction: e.g, we can construct a struct from a single identically typed object.
          if (function.getParamCount() == 1 && type == *function[0].type)
              return false;
  
          if ((int)type.getStruct()->size() != function.getParamCount()) {
              error(loc, "Number of constructor parameters does not match the number of structure fields", "constructor", "");
              return true;
          }
      }
  
      if ((op != EOpConstructStruct && size != 1 && size < type.computeNumComponents()) ||
          (op == EOpConstructStruct && size < type.computeNumComponents())) {
          error(loc, "not enough data provided for construction", "constructor", "");
          return true;
      }
  
      return false;
  }
  
  // See if 'node', in the context of constructing aggregates, is a scalar argument
  // to a constructor.
  //
  bool HlslParseContext::isScalarConstructor(const TIntermNode* node)
  {
      // Obviously, it must be a scalar, but an aggregate node might not be fully
      // completed yet: holding a sequence of initializers under an aggregate
      // would not yet be typed, so don't check it's type.  This corresponds to
      // the aggregate operator also not being set yet. (An aggregate operation
      // that legitimately yields a scalar will have a getOp() of that operator,
      // not EOpNull.)
  
      return node->getAsTyped() != nullptr &&
             node->getAsTyped()->isScalar() &&
             (node->getAsAggregate() == nullptr || node->getAsAggregate()->getOp() != EOpNull);
  }
  
  // Checks to see if a void variable has been declared and raise an error message for such a case
  //
  // returns true in case of an error
  //
  bool HlslParseContext::voidErrorCheck(const TSourceLoc& loc, const TString& identifier, const TBasicType basicType)
  {
      if (basicType == EbtVoid) {
          error(loc, "illegal use of type 'void'", identifier.c_str(), "");
          return true;
      }
  
      return false;
  }
  
  //
  // Fix just a full qualifier (no variables or types yet, but qualifier is complete) at global level.
  //
  void HlslParseContext::globalQualifierFix(const TSourceLoc&, TQualifier& qualifier)
  {
      // move from parameter/unknown qualifiers to pipeline in/out qualifiers
      switch (qualifier.storage) {
      case EvqIn:
          qualifier.storage = EvqVaryingIn;
          break;
      case EvqOut:
          qualifier.storage = EvqVaryingOut;
          break;
      default:
          break;
      }
  }
  
  //
  // Merge characteristics of the 'src' qualifier into the 'dst'.
  // If there is duplication, issue error messages, unless 'force'
  // is specified, which means to just override default settings.
  //
  // Also, when force is false, it will be assumed that 'src' follows
  // 'dst', for the purpose of error checking order for versions
  // that require specific orderings of qualifiers.
  //
  void HlslParseContext::mergeQualifiers(TQualifier& dst, const TQualifier& src)
  {
      // Storage qualification
      if (dst.storage == EvqTemporary || dst.storage == EvqGlobal)
          dst.storage = src.storage;
      else if ((dst.storage == EvqIn  && src.storage == EvqOut) ||
               (dst.storage == EvqOut && src.storage == EvqIn))
          dst.storage = EvqInOut;
      else if ((dst.storage == EvqIn    && src.storage == EvqConst) ||
               (dst.storage == EvqConst && src.storage == EvqIn))
          dst.storage = EvqConstReadOnly;
  
      // Layout qualifiers
      mergeObjectLayoutQualifiers(dst, src, false);
  
      // individual qualifiers
      bool repeated = false;
  #define MERGE_SINGLETON(field) repeated |= dst.field && src.field; dst.field |= src.field;
      MERGE_SINGLETON(invariant);
      MERGE_SINGLETON(noContraction);
      MERGE_SINGLETON(centroid);
      MERGE_SINGLETON(smooth);
      MERGE_SINGLETON(flat);
      MERGE_SINGLETON(nopersp);
      MERGE_SINGLETON(patch);
      MERGE_SINGLETON(sample);
      MERGE_SINGLETON(coherent);
      MERGE_SINGLETON(volatil);
      MERGE_SINGLETON(restrict);
      MERGE_SINGLETON(readonly);
      MERGE_SINGLETON(writeonly);
      MERGE_SINGLETON(specConstant);
      MERGE_SINGLETON(nonUniform);
  }
  
  // used to flatten the sampler type space into a single dimension
  // correlates with the declaration of defaultSamplerPrecision[]
  int HlslParseContext::computeSamplerTypeIndex(TSampler& sampler)
  {
      int arrayIndex = sampler.arrayed ? 1 : 0;
      int shadowIndex = sampler.shadow ? 1 : 0;
      int externalIndex = sampler.external ? 1 : 0;
  
      return EsdNumDims *
             (EbtNumTypes * (2 * (2 * arrayIndex + shadowIndex) + externalIndex) + sampler.type) + sampler.dim;
  }
  
  //
  // Do size checking for an array type's size.
  //
  void HlslParseContext::arraySizeCheck(const TSourceLoc& loc, TIntermTyped* expr, TArraySize& sizePair)
  {
      bool isConst = false;
      sizePair.size = 1;
      sizePair.node = nullptr;
  
      TIntermConstantUnion* constant = expr->getAsConstantUnion();
      if (constant) {
          // handle true (non-specialization) constant
          sizePair.size = constant->getConstArray()[0].getIConst();
          isConst = true;
      } else {
          // see if it's a specialization constant instead
          if (expr->getQualifier().isSpecConstant()) {
              isConst = true;
              sizePair.node = expr;
              TIntermSymbol* symbol = expr->getAsSymbolNode();
              if (symbol && symbol->getConstArray().size() > 0)
                  sizePair.size = symbol->getConstArray()[0].getIConst();
          }
      }
  
      if (! isConst || (expr->getBasicType() != EbtInt && expr->getBasicType() != EbtUint)) {
          error(loc, "array size must be a constant integer expression", "", "");
          return;
      }
  
      if (sizePair.size <= 0) {
          error(loc, "array size must be a positive integer", "", "");
          return;
      }
  }
  
  //
  // Require array to be completely sized
  //
  void HlslParseContext::arraySizeRequiredCheck(const TSourceLoc& loc, const TArraySizes& arraySizes)
  {
      if (arraySizes.hasUnsized())
          error(loc, "array size required", "", "");
  }
  
  void HlslParseContext::structArrayCheck(const TSourceLoc& /*loc*/, const TType& type)
  {
      const TTypeList& structure = *type.getStruct();
      for (int m = 0; m < (int)structure.size(); ++m) {
          const TType& member = *structure[m].type;
          if (member.isArray())
              arraySizeRequiredCheck(structure[m].loc, *member.getArraySizes());
      }
  }
  
  //
  // Do all the semantic checking for declaring or redeclaring an array, with and
  // without a size, and make the right changes to the symbol table.
  //
  void HlslParseContext::declareArray(const TSourceLoc& loc, const TString& identifier, const TType& type,
                                      TSymbol*& symbol, bool track)
  {
      if (symbol == nullptr) {
          bool currentScope;
          symbol = symbolTable.find(identifier, nullptr, &currentScope);
  
          if (symbol && builtInName(identifier) && ! symbolTable.atBuiltInLevel()) {
              // bad shader (errors already reported) trying to redeclare a built-in name as an array
              return;
          }
          if (symbol == nullptr || ! currentScope) {
              //
              // Successfully process a new definition.
              // (Redeclarations have to take place at the same scope; otherwise they are hiding declarations)
              //
              symbol = new TVariable(&identifier, type);
              symbolTable.insert(*symbol);
              if (track && symbolTable.atGlobalLevel())
                  trackLinkage(*symbol);
  
              return;
          }
          if (symbol->getAsAnonMember()) {
              error(loc, "cannot redeclare a user-block member array", identifier.c_str(), "");
              symbol = nullptr;
              return;
          }
      }
  
      //
      // Process a redeclaration.
      //
  
      if (symbol == nullptr) {
          error(loc, "array variable name expected", identifier.c_str(), "");
          return;
      }
  
      // redeclareBuiltinVariable() should have already done the copyUp()
      TType& existingType = symbol->getWritableType();
  
      if (existingType.isSizedArray()) {
          // be more lenient for input arrays to geometry shaders and tessellation control outputs,
          // where the redeclaration is the same size
          return;
      }
  
      existingType.updateArraySizes(type);
  }
  
  //
  // Enforce non-initializer type/qualifier rules.
  //
  void HlslParseContext::fixConstInit(const TSourceLoc& loc, const TString& identifier, TType& type,
                                      TIntermTyped*& initializer)
  {
      //
      // Make the qualifier make sense, given that there is an initializer.
      //
      if (initializer == nullptr) {
          if (type.getQualifier().storage == EvqConst ||
              type.getQualifier().storage == EvqConstReadOnly) {
              initializer = intermediate.makeAggregate(loc);
              warn(loc, "variable with qualifier 'const' not initialized; zero initializing", identifier.c_str(), "");
          }
      }
  }
  
  //
  // See if the identifier is a built-in symbol that can be redeclared, and if so,
  // copy the symbol table's read-only built-in variable to the current
  // global level, where it can be modified based on the passed in type.
  //
  // Returns nullptr if no redeclaration took place; meaning a normal declaration still
  // needs to occur for it, not necessarily an error.
  //
  // Returns a redeclared and type-modified variable if a redeclared occurred.
  //
  TSymbol* HlslParseContext::redeclareBuiltinVariable(const TSourceLoc& /*loc*/, const TString& identifier,
                                                      const TQualifier& /*qualifier*/,
                                                      const TShaderQualifiers& /*publicType*/)
  {
      if (! builtInName(identifier) || symbolTable.atBuiltInLevel() || ! symbolTable.atGlobalLevel())
          return nullptr;
  
      return nullptr;
  }
  
  //
  // Generate index to the array element in a structure buffer (SSBO)
  //
  TIntermTyped* HlslParseContext::indexStructBufferContent(const TSourceLoc& loc, TIntermTyped* buffer) const
  {
      // Bail out if not a struct buffer
      if (buffer == nullptr || ! isStructBufferType(buffer->getType()))
          return nullptr;
  
      // Runtime sized array is always the last element.
      const TTypeList* bufferStruct = buffer->getType().getStruct();
      TIntermTyped* arrayPosition = intermediate.addConstantUnion(unsigned(bufferStruct->size()-1), loc);
  
      TIntermTyped* argArray = intermediate.addIndex(EOpIndexDirectStruct, buffer, arrayPosition, loc);
      argArray->setType(*(*bufferStruct)[bufferStruct->size()-1].type);
  
      return argArray;
  }
  
  //
  // IFF type is a structuredbuffer/byteaddressbuffer type, return the content
  // (template) type.   E.g, StructuredBuffer<MyType> -> MyType.  Else return nullptr.
  //
  TType* HlslParseContext::getStructBufferContentType(const TType& type) const
  {
      if (type.getBasicType() != EbtBlock || type.getQualifier().storage != EvqBuffer)
          return nullptr;
  
      const int memberCount = (int)type.getStruct()->size();
      assert(memberCount > 0);
  
      TType* contentType = (*type.getStruct())[memberCount-1].type;
  
      return contentType->isUnsizedArray() ? contentType : nullptr;
  }
  
  //
  // If an existing struct buffer has a sharable type, then share it.
  //
  void HlslParseContext::shareStructBufferType(TType& type)
  {
      // PackOffset must be equivalent to share types on a per-member basis.
      // Note: cannot use auto type due to recursion.  Thus, this is a std::function.
      const std::function<bool(TType& lhs, TType& rhs)>
      compareQualifiers = [&](TType& lhs, TType& rhs) -> bool {
          if (lhs.getQualifier().layoutOffset != rhs.getQualifier().layoutOffset)
              return false;
  
          if (lhs.isStruct() != rhs.isStruct())
              return false;
  
          if (lhs.isStruct() && rhs.isStruct()) {
              if (lhs.getStruct()->size() != rhs.getStruct()->size())
                  return false;
  
              for (int i = 0; i < int(lhs.getStruct()->size()); ++i)
                  if (!compareQualifiers(*(*lhs.getStruct())[i].type, *(*rhs.getStruct())[i].type))
                      return false;
          }
  
          return true;
      };
  
      // We need to compare certain qualifiers in addition to the type.
      const auto typeEqual = [compareQualifiers](TType& lhs, TType& rhs) -> bool {
          if (lhs.getQualifier().readonly != rhs.getQualifier().readonly)
              return false;
  
          // If both are structures, recursively look for packOffset equality
          // as well as type equality.
          return compareQualifiers(lhs, rhs) && lhs == rhs;
      };
  
      // This is an exhaustive O(N) search, but real world shaders have
      // only a small number of these.
      for (int idx = 0; idx < int(structBufferTypes.size()); ++idx) {
          // If the deep structure matches, modulo qualifiers, use it
          if (typeEqual(*structBufferTypes[idx], type)) {
              type.shallowCopy(*structBufferTypes[idx]);
              return;
          }
      }
  
      // Otherwise, remember it:
      TType* typeCopy = new TType;
      typeCopy->shallowCopy(type);
      structBufferTypes.push_back(typeCopy);
  }
  
  void HlslParseContext::paramFix(TType& type)
  {
      switch (type.getQualifier().storage) {
      case EvqConst:
          type.getQualifier().storage = EvqConstReadOnly;
          break;
      case EvqGlobal:
      case EvqUniform:
      case EvqTemporary:
          type.getQualifier().storage = EvqIn;
          break;
      case EvqBuffer:
          {
              // SSBO parameter.  These do not go through the declareBlock path since they are fn parameters.
              correctUniform(type.getQualifier());
              TQualifier bufferQualifier = globalBufferDefaults;
              mergeObjectLayoutQualifiers(bufferQualifier, type.getQualifier(), true);
              bufferQualifier.storage = type.getQualifier().storage;
              bufferQualifier.readonly = type.getQualifier().readonly;
              bufferQualifier.coherent = type.getQualifier().coherent;
              bufferQualifier.declaredBuiltIn = type.getQualifier().declaredBuiltIn;
              type.getQualifier() = bufferQualifier;
              break;
          }
      default:
          break;
      }
  }
  
  void HlslParseContext::specializationCheck(const TSourceLoc& loc, const TType& type, const char* op)
  {
      if (type.containsSpecializationSize())
          error(loc, "can't use with types containing arrays sized with a specialization constant", op, "");
  }
  
  //
  // Layout qualifier stuff.
  //
  
  // Put the id's layout qualification into the public type, for qualifiers not having a number set.
  // This is before we know any type information for error checking.
  void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qualifier, TString& id)
  {
      std::transform(id.begin(), id.end(), id.begin(), ::tolower);
  
      if (id == TQualifier::getLayoutMatrixString(ElmColumnMajor)) {
          qualifier.layoutMatrix = ElmRowMajor;
          return;
      }
      if (id == TQualifier::getLayoutMatrixString(ElmRowMajor)) {
          qualifier.layoutMatrix = ElmColumnMajor;
          return;
      }
      if (id == "push_constant") {
          requireVulkan(loc, "push_constant");
          qualifier.layoutPushConstant = true;
          return;
      }
      if (language == EShLangGeometry || language == EShLangTessEvaluation) {
          if (id == TQualifier::getGeometryString(ElgTriangles)) {
              // publicType.shaderQualifiers.geometry = ElgTriangles;
              warn(loc, "ignored", id.c_str(), "");
              return;
          }
          if (language == EShLangGeometry) {
              if (id == TQualifier::getGeometryString(ElgPoints)) {
                  // publicType.shaderQualifiers.geometry = ElgPoints;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgLineStrip)) {
                  // publicType.shaderQualifiers.geometry = ElgLineStrip;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgLines)) {
                  // publicType.shaderQualifiers.geometry = ElgLines;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgLinesAdjacency)) {
                  // publicType.shaderQualifiers.geometry = ElgLinesAdjacency;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgTrianglesAdjacency)) {
                  // publicType.shaderQualifiers.geometry = ElgTrianglesAdjacency;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgTriangleStrip)) {
                  // publicType.shaderQualifiers.geometry = ElgTriangleStrip;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
          } else {
              assert(language == EShLangTessEvaluation);
  
              // input primitive
              if (id == TQualifier::getGeometryString(ElgTriangles)) {
                  // publicType.shaderQualifiers.geometry = ElgTriangles;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgQuads)) {
                  // publicType.shaderQualifiers.geometry = ElgQuads;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getGeometryString(ElgIsolines)) {
                  // publicType.shaderQualifiers.geometry = ElgIsolines;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
  
              // vertex spacing
              if (id == TQualifier::getVertexSpacingString(EvsEqual)) {
                  // publicType.shaderQualifiers.spacing = EvsEqual;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getVertexSpacingString(EvsFractionalEven)) {
                  // publicType.shaderQualifiers.spacing = EvsFractionalEven;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getVertexSpacingString(EvsFractionalOdd)) {
                  // publicType.shaderQualifiers.spacing = EvsFractionalOdd;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
  
              // triangle order
              if (id == TQualifier::getVertexOrderString(EvoCw)) {
                  // publicType.shaderQualifiers.order = EvoCw;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == TQualifier::getVertexOrderString(EvoCcw)) {
                  // publicType.shaderQualifiers.order = EvoCcw;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
  
              // point mode
              if (id == "point_mode") {
                  // publicType.shaderQualifiers.pointMode = true;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
          }
      }
      if (language == EShLangFragment) {
          if (id == "origin_upper_left") {
              // publicType.shaderQualifiers.originUpperLeft = true;
              warn(loc, "ignored", id.c_str(), "");
              return;
          }
          if (id == "pixel_center_integer") {
              // publicType.shaderQualifiers.pixelCenterInteger = true;
              warn(loc, "ignored", id.c_str(), "");
              return;
          }
          if (id == "early_fragment_tests") {
              // publicType.shaderQualifiers.earlyFragmentTests = true;
              warn(loc, "ignored", id.c_str(), "");
              return;
          }
          for (TLayoutDepth depth = (TLayoutDepth)(EldNone + 1); depth < EldCount; depth = (TLayoutDepth)(depth + 1)) {
              if (id == TQualifier::getLayoutDepthString(depth)) {
                  // publicType.shaderQualifiers.layoutDepth = depth;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
          }
          if (id.compare(0, 13, "blend_support") == 0) {
              bool found = false;
              for (TBlendEquationShift be = (TBlendEquationShift)0; be < EBlendCount; be = (TBlendEquationShift)(be + 1)) {
                  if (id == TQualifier::getBlendEquationString(be)) {
                      requireExtensions(loc, 1, &E_GL_KHR_blend_equation_advanced, "blend equation");
                      intermediate.addBlendEquation(be);
                      // publicType.shaderQualifiers.blendEquation = true;
                      warn(loc, "ignored", id.c_str(), "");
                      found = true;
                      break;
                  }
              }
              if (! found)
                  error(loc, "unknown blend equation", "blend_support", "");
              return;
          }
      }
      error(loc, "unrecognized layout identifier, or qualifier requires assignment (e.g., binding = 4)", id.c_str(), "");
  }
  
  // Put the id's layout qualifier value into the public type, for qualifiers having a number set.
  // This is before we know any type information for error checking.
  void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qualifier, TString& id,
                                            const TIntermTyped* node)
  {
      const char* feature = "layout-id value";
      // const char* nonLiteralFeature = "non-literal layout-id value";
  
      integerCheck(node, feature);
      const TIntermConstantUnion* constUnion = node->getAsConstantUnion();
      int value = 0;
      if (constUnion) {
          value = constUnion->getConstArray()[0].getIConst();
      }
  
      std::transform(id.begin(), id.end(), id.begin(), ::tolower);
  
      if (id == "offset") {
          qualifier.layoutOffset = value;
          return;
      } else if (id == "align") {
          // "The specified alignment must be a power of 2, or a compile-time error results."
          if (! IsPow2(value))
              error(loc, "must be a power of 2", "align", "");
          else
              qualifier.layoutAlign = value;
          return;
      } else if (id == "location") {
          if ((unsigned int)value >= TQualifier::layoutLocationEnd)
              error(loc, "location is too large", id.c_str(), "");
          else
              qualifier.layoutLocation = value;
          return;
      } else if (id == "set") {
          if ((unsigned int)value >= TQualifier::layoutSetEnd)
              error(loc, "set is too large", id.c_str(), "");
          else
              qualifier.layoutSet = value;
          return;
      } else if (id == "binding") {
          if ((unsigned int)value >= TQualifier::layoutBindingEnd)
              error(loc, "binding is too large", id.c_str(), "");
          else
              qualifier.layoutBinding = value;
          return;
      } else if (id == "component") {
          if ((unsigned)value >= TQualifier::layoutComponentEnd)
              error(loc, "component is too large", id.c_str(), "");
          else
              qualifier.layoutComponent = value;
          return;
      } else if (id.compare(0, 4, "xfb_") == 0) {
          // "Any shader making any static use (after preprocessing) of any of these
          // *xfb_* qualifiers will cause the shader to be in a transform feedback
          // capturing mode and hence responsible for describing the transform feedback
          // setup."
          intermediate.setXfbMode();
          if (id == "xfb_buffer") {
              // "It is a compile-time error to specify an *xfb_buffer* that is greater than
              // the implementation-dependent constant gl_MaxTransformFeedbackBuffers."
              if (value >= resources.maxTransformFeedbackBuffers)
                  error(loc, "buffer is too large:", id.c_str(), "gl_MaxTransformFeedbackBuffers is %d",
                        resources.maxTransformFeedbackBuffers);
              if (value >= (int)TQualifier::layoutXfbBufferEnd)
                  error(loc, "buffer is too large:", id.c_str(), "internal max is %d", TQualifier::layoutXfbBufferEnd - 1);
              else
                  qualifier.layoutXfbBuffer = value;
              return;
          } else if (id == "xfb_offset") {
              if (value >= (int)TQualifier::layoutXfbOffsetEnd)
                  error(loc, "offset is too large:", id.c_str(), "internal max is %d", TQualifier::layoutXfbOffsetEnd - 1);
              else
                  qualifier.layoutXfbOffset = value;
              return;
          } else if (id == "xfb_stride") {
              // "The resulting stride (implicit or explicit), when divided by 4, must be less than or equal to the
              // implementation-dependent constant gl_MaxTransformFeedbackInterleavedComponents."
              if (value > 4 * resources.maxTransformFeedbackInterleavedComponents)
                  error(loc, "1/4 stride is too large:", id.c_str(), "gl_MaxTransformFeedbackInterleavedComponents is %d",
                        resources.maxTransformFeedbackInterleavedComponents);
              else if (value >= (int)TQualifier::layoutXfbStrideEnd)
                  error(loc, "stride is too large:", id.c_str(), "internal max is %d", TQualifier::layoutXfbStrideEnd - 1);
              if (value < (int)TQualifier::layoutXfbStrideEnd)
                  qualifier.layoutXfbStride = value;
              return;
          }
      }
  
      if (id == "input_attachment_index") {
          requireVulkan(loc, "input_attachment_index");
          if (value >= (int)TQualifier::layoutAttachmentEnd)
              error(loc, "attachment index is too large", id.c_str(), "");
          else
              qualifier.layoutAttachment = value;
          return;
      }
      if (id == "constant_id") {
          setSpecConstantId(loc, qualifier, value);
          return;
      }
  
      switch (language) {
      case EShLangVertex:
          break;
  
      case EShLangTessControl:
          if (id == "vertices") {
              if (value == 0)
                  error(loc, "must be greater than 0", "vertices", "");
              else
                  // publicType.shaderQualifiers.vertices = value;
                  warn(loc, "ignored", id.c_str(), "");
              return;
          }
          break;
  
      case EShLangTessEvaluation:
          break;
  
      case EShLangGeometry:
          if (id == "invocations") {
              if (value == 0)
                  error(loc, "must be at least 1", "invocations", "");
              else
                  // publicType.shaderQualifiers.invocations = value;
                  warn(loc, "ignored", id.c_str(), "");
              return;
          }
          if (id == "max_vertices") {
              // publicType.shaderQualifiers.vertices = value;
              warn(loc, "ignored", id.c_str(), "");
              if (value > resources.maxGeometryOutputVertices)
                  error(loc, "too large, must be less than gl_MaxGeometryOutputVertices", "max_vertices", "");
              return;
          }
          if (id == "stream") {
              qualifier.layoutStream = value;
              return;
          }
          break;
  
      case EShLangFragment:
          if (id == "index") {
              qualifier.layoutIndex = value;
              return;
          }
          break;
  
      case EShLangCompute:
          if (id.compare(0, 11, "local_size_") == 0) {
              if (id == "local_size_x") {
                  // publicType.shaderQualifiers.localSize[0] = value;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == "local_size_y") {
                  // publicType.shaderQualifiers.localSize[1] = value;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (id == "local_size_z") {
                  // publicType.shaderQualifiers.localSize[2] = value;
                  warn(loc, "ignored", id.c_str(), "");
                  return;
              }
              if (spvVersion.spv != 0) {
                  if (id == "local_size_x_id") {
                      // publicType.shaderQualifiers.localSizeSpecId[0] = value;
                      warn(loc, "ignored", id.c_str(), "");
                      return;
                  }
                  if (id == "local_size_y_id") {
                      // publicType.shaderQualifiers.localSizeSpecId[1] = value;
                      warn(loc, "ignored", id.c_str(), "");
                      return;
                  }
                  if (id == "local_size_z_id") {
                      // publicType.shaderQualifiers.localSizeSpecId[2] = value;
                      warn(loc, "ignored", id.c_str(), "");
                      return;
                  }
              }
          }
          break;
  
      default:
          break;
      }
  
      error(loc, "there is no such layout identifier for this stage taking an assigned value", id.c_str(), "");
  }
  
  void HlslParseContext::setSpecConstantId(const TSourceLoc& loc, TQualifier& qualifier, int value)
  {
      if (value >= (int)TQualifier::layoutSpecConstantIdEnd) {
          error(loc, "specialization-constant id is too large", "constant_id", "");
      } else {
          qualifier.layoutSpecConstantId = value;
          qualifier.specConstant = true;
          if (! intermediate.addUsedConstantId(value))
              error(loc, "specialization-constant id already used", "constant_id", "");
      }
      return;
  }
  
  // Merge any layout qualifier information from src into dst, leaving everything else in dst alone
  //
  // "More than one layout qualifier may appear in a single declaration.
  // Additionally, the same layout-qualifier-name can occur multiple times
  // within a layout qualifier or across multiple layout qualifiers in the
  // same declaration. When the same layout-qualifier-name occurs
  // multiple times, in a single declaration, the last occurrence overrides
  // the former occurrence(s).  Further, if such a layout-qualifier-name
  // will effect subsequent declarations or other observable behavior, it
  // is only the last occurrence that will have any effect, behaving as if
  // the earlier occurrence(s) within the declaration are not present.
  // This is also true for overriding layout-qualifier-names, where one
  // overrides the other (e.g., row_major vs. column_major); only the last
  // occurrence has any effect."
  //
  void HlslParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQualifier& src, bool inheritOnly)
  {
      if (src.hasMatrix())
          dst.layoutMatrix = src.layoutMatrix;
      if (src.hasPacking())
          dst.layoutPacking = src.layoutPacking;
  
      if (src.hasStream())
          dst.layoutStream = src.layoutStream;
  
      if (src.hasFormat())
          dst.layoutFormat = src.layoutFormat;
  
      if (src.hasXfbBuffer())
          dst.layoutXfbBuffer = src.layoutXfbBuffer;
  
      if (src.hasAlign())
          dst.layoutAlign = src.layoutAlign;
  
      if (! inheritOnly) {
          if (src.hasLocation())
              dst.layoutLocation = src.layoutLocation;
          if (src.hasComponent())
              dst.layoutComponent = src.layoutComponent;
          if (src.hasIndex())
              dst.layoutIndex = src.layoutIndex;
  
          if (src.hasOffset())
              dst.layoutOffset = src.layoutOffset;
  
          if (src.hasSet())
              dst.layoutSet = src.layoutSet;
          if (src.layoutBinding != TQualifier::layoutBindingEnd)
              dst.layoutBinding = src.layoutBinding;
  
          if (src.hasXfbStride())
              dst.layoutXfbStride = src.layoutXfbStride;
          if (src.hasXfbOffset())
              dst.layoutXfbOffset = src.layoutXfbOffset;
          if (src.hasAttachment())
              dst.layoutAttachment = src.layoutAttachment;
          if (src.hasSpecConstantId())
              dst.layoutSpecConstantId = src.layoutSpecConstantId;
  
          if (src.layoutPushConstant)
              dst.layoutPushConstant = true;
      }
  }
  
  
  //
  // Look up a function name in the symbol table, and make sure it is a function.
  //
  // First, look for an exact match.  If there is none, use the generic selector
  // TParseContextBase::selectFunction() to find one, parameterized by the
  // convertible() and better() predicates defined below.
  //
  // Return the function symbol if found, otherwise nullptr.
  //
  const TFunction* HlslParseContext::findFunction(const TSourceLoc& loc, TFunction& call, bool& builtIn, int& thisDepth,
                                                  TIntermTyped*& args)
  {
      if (symbolTable.isFunctionNameVariable(call.getName())) {
          error(loc, "can't use function syntax on variable", call.getName().c_str(), "");
          return nullptr;
      }
  
      // first, look for an exact match
      bool dummyScope;
      TSymbol* symbol = symbolTable.find(call.getMangledName(), &builtIn, &dummyScope, &thisDepth);
      if (symbol)
          return symbol->getAsFunction();
  
      // no exact match, use the generic selector, parameterized by the GLSL rules
  
      // create list of candidates to send
      TVector<const TFunction*> candidateList;
      symbolTable.findFunctionNameList(call.getMangledName(), candidateList, builtIn);
  
      // These built-in ops can accept any type, so we bypass the argument selection
      if (candidateList.size() == 1 && builtIn &&
          (candidateList[0]->getBuiltInOp() == EOpMethodAppend ||
           candidateList[0]->getBuiltInOp() == EOpMethodRestartStrip ||
           candidateList[0]->getBuiltInOp() == EOpMethodIncrementCounter ||
           candidateList[0]->getBuiltInOp() == EOpMethodDecrementCounter ||
           candidateList[0]->getBuiltInOp() == EOpMethodAppend ||
           candidateList[0]->getBuiltInOp() == EOpMethodConsume)) {
          return candidateList[0];
      }
  
      bool allowOnlyUpConversions = true;
  
      // can 'from' convert to 'to'?
      const auto convertible = [&](const TType& from, const TType& to, TOperator op, int arg) -> bool {
          if (from == to)
              return true;
  
          // no aggregate conversions
          if (from.isArray()  || to.isArray() ||
              from.isStruct() || to.isStruct())
              return false;
  
          switch (op) {
          case EOpInterlockedAdd:
          case EOpInterlockedAnd:
          case EOpInterlockedCompareExchange:
          case EOpInterlockedCompareStore:
          case EOpInterlockedExchange:
          case EOpInterlockedMax:
          case EOpInterlockedMin:
          case EOpInterlockedOr:
          case EOpInterlockedXor:
              // We do not promote the texture or image type for these ocodes.  Normally that would not
              // be an issue because it's a buffer, but we haven't decomposed the opcode yet, and at this
              // stage it's merely e.g, a basic integer type.
              //
              // Instead, we want to promote other arguments, but stay within the same family.  In other
              // words, InterlockedAdd(RWBuffer<int>, ...) will always use the int flavor, never the uint flavor,
              // but it is allowed to promote its other arguments.
              if (arg == 0)
                  return false;
              break;
          case EOpMethodSample:
          case EOpMethodSampleBias:
          case EOpMethodSampleCmp:
          case EOpMethodSampleCmpLevelZero:
          case EOpMethodSampleGrad:
          case EOpMethodSampleLevel:
          case EOpMethodLoad:
          case EOpMethodGetDimensions:
          case EOpMethodGetSamplePosition:
          case EOpMethodGather:
          case EOpMethodCalculateLevelOfDetail:
          case EOpMethodCalculateLevelOfDetailUnclamped:
          case EOpMethodGatherRed:
          case EOpMethodGatherGreen:
          case EOpMethodGatherBlue:
          case EOpMethodGatherAlpha:
          case EOpMethodGatherCmp:
          case EOpMethodGatherCmpRed:
          case EOpMethodGatherCmpGreen:
          case EOpMethodGatherCmpBlue:
          case EOpMethodGatherCmpAlpha:
          case EOpMethodAppend:
          case EOpMethodRestartStrip:
              // those are method calls, the object type can not be changed
              // they are equal if the dim and type match (is dim sufficient?)
              if (arg == 0)
                  return from.getSampler().type == to.getSampler().type &&
                         from.getSampler().arrayed == to.getSampler().arrayed &&
                         from.getSampler().shadow == to.getSampler().shadow &&
                         from.getSampler().ms == to.getSampler().ms &&
                         from.getSampler().dim == to.getSampler().dim;
              break;
          default:
              break;
          }
  
          // basic types have to be convertible
          if (allowOnlyUpConversions)
              if (! intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType(), EOpFunctionCall))
                  return false;
  
          // shapes have to be convertible
          if ((from.isScalarOrVec1() && to.isScalarOrVec1()) ||
              (from.isScalarOrVec1() && to.isVector())    ||
              (from.isScalarOrVec1() && to.isMatrix())    ||
              (from.isVector() && to.isVector() && from.getVectorSize() >= to.getVectorSize()))
              return true;
  
          // TODO: what are the matrix rules? they go here
  
          return false;
      };
  
      // Is 'to2' a better conversion than 'to1'?
      // Ties should not be considered as better.
      // Assumes 'convertible' already said true.
      const auto better = [](const TType& from, const TType& to1, const TType& to2) -> bool {
          // exact match is always better than mismatch
          if (from == to2)
              return from != to1;
          if (from == to1)
              return false;
  
          // shape changes are always worse
          if (from.isScalar() || from.isVector()) {
              if (from.getVectorSize() == to2.getVectorSize() &&
                  from.getVectorSize() != to1.getVectorSize())
                  return true;
              if (from.getVectorSize() == to1.getVectorSize() &&
                  from.getVectorSize() != to2.getVectorSize())
                  return false;
          }
  
          // Handle sampler betterness: An exact sampler match beats a non-exact match.
          // (If we just looked at basic type, all EbtSamplers would look the same).
          // If any type is not a sampler, just use the linearize function below.
          if (from.getBasicType() == EbtSampler && to1.getBasicType() == EbtSampler && to2.getBasicType() == EbtSampler) {
              // We can ignore the vector size in the comparison.
              TSampler to1Sampler = to1.getSampler();
              TSampler to2Sampler = to2.getSampler();
  
              to1Sampler.vectorSize = to2Sampler.vectorSize = from.getSampler().vectorSize;
  
              if (from.getSampler() == to2Sampler)
                  return from.getSampler() != to1Sampler;
              if (from.getSampler() == to1Sampler)
                  return false;
          }
  
          // Might or might not be changing shape, which means basic type might
          // or might not match, so within that, the question is how big a
          // basic-type conversion is being done.
          //
          // Use a hierarchy of domains, translated to order of magnitude
          // in a linearized view:
          //   - floating-point vs. integer
          //     - 32 vs. 64 bit (or width in general)
          //       - bool vs. non bool
          //         - signed vs. not signed
          const auto linearize = [](const TBasicType& basicType) -> int {
              switch (basicType) {
              case EbtBool:     return 1;
              case EbtInt:      return 10;
              case EbtUint:     return 11;
              case EbtInt64:    return 20;
              case EbtUint64:   return 21;
              case EbtFloat:    return 100;
              case EbtDouble:   return 110;
              default:          return 0;
              }
          };
  
          return abs(linearize(to2.getBasicType()) - linearize(from.getBasicType())) <
                 abs(linearize(to1.getBasicType()) - linearize(from.getBasicType()));
      };
  
      // for ambiguity reporting
      bool tie = false;
  
      // send to the generic selector
      const TFunction* bestMatch = selectFunction(candidateList, call, convertible, better, tie);
  
      if (bestMatch == nullptr) {
          // If there is nothing selected by allowing only up-conversions (to a larger linearize() value),
          // we instead try down-conversions, which are valid in HLSL, but not preferred if there are any
          // upconversions possible.
          allowOnlyUpConversions = false;
          bestMatch = selectFunction(candidateList, call, convertible, better, tie);
      }
  
      if (bestMatch == nullptr) {
          error(loc, "no matching overloaded function found", call.getName().c_str(), "");
          return nullptr;
      }
  
      // For built-ins, we can convert across the arguments.  This will happen in several steps:
      // Step 1:  If there's an exact match, use it.
      // Step 2a: Otherwise, get the operator from the best match and promote arguments:
      // Step 2b: reconstruct the TFunction based on the new arg types
      // Step 3:  Re-select after type promotion is applied, to find proper candidate.
      if (builtIn) {
          // Step 1: If there's an exact match, use it.
          if (call.getMangledName() == bestMatch->getMangledName())
              return bestMatch;
  
          // Step 2a: Otherwise, get the operator from the best match and promote arguments as if we
          // are that kind of operator.
          if (args != nullptr) {
              // The arg list can be a unary node, or an aggregate.  We have to handle both.
              // We will use the normal promote() facilities, which require an interm node.
              TIntermOperator* promote = nullptr;
  
              if (call.getParamCount() == 1) {
                  promote = new TIntermUnary(bestMatch->getBuiltInOp());
                  promote->getAsUnaryNode()->setOperand(args->getAsTyped());
              } else {
                  promote = new TIntermAggregate(bestMatch->getBuiltInOp());
                  promote->getAsAggregate()->getSequence().swap(args->getAsAggregate()->getSequence());
              }
  
              if (! intermediate.promote(promote))
                  return nullptr;
  
              // Obtain the promoted arg list.
              if (call.getParamCount() == 1) {
                  args = promote->getAsUnaryNode()->getOperand();
              } else {
                  promote->getAsAggregate()->getSequence().swap(args->getAsAggregate()->getSequence());
              }
          }
  
          // Step 2b: reconstruct the TFunction based on the new arg types
          TFunction convertedCall(&call.getName(), call.getType(), call.getBuiltInOp());
  
          if (args->getAsAggregate()) {
              // Handle aggregates: put all args into the new function call
              for (int arg = 0; arg < int(args->getAsAggregate()->getSequence().size()); ++arg) {
                  // TODO: But for constness, we could avoid the new & shallowCopy, and use the pointer directly.
                  TParameter param = { 0, new TType, nullptr };
                  param.type->shallowCopy(args->getAsAggregate()->getSequence()[arg]->getAsTyped()->getType());
                  convertedCall.addParameter(param);
              }
          } else if (args->getAsUnaryNode()) {
              // Handle unaries: put all args into the new function call
              TParameter param = { 0, new TType, nullptr };
              param.type->shallowCopy(args->getAsUnaryNode()->getOperand()->getAsTyped()->getType());
              convertedCall.addParameter(param);
          } else if (args->getAsTyped()) {
              // Handle bare e.g, floats, not in an aggregate.
              TParameter param = { 0, new TType, nullptr };
              param.type->shallowCopy(args->getAsTyped()->getType());
              convertedCall.addParameter(param);
          } else {
              assert(0); // unknown argument list.
              return nullptr;
          }
  
          // Step 3: Re-select after type promotion, to find proper candidate
          // send to the generic selector
          bestMatch = selectFunction(candidateList, convertedCall, convertible, better, tie);
  
          // At this point, there should be no tie.
      }
  
      if (tie)
          error(loc, "ambiguous best function under implicit type conversion", call.getName().c_str(), "");
  
      // Append default parameter values if needed
      if (!tie && bestMatch != nullptr) {
          for (int defParam = call.getParamCount(); defParam < bestMatch->getParamCount(); ++defParam) {
              handleFunctionArgument(&call, args, (*bestMatch)[defParam].defaultValue);
          }
      }
  
      return bestMatch;
  }
  
  //
  // Do everything necessary to handle a typedef declaration, for a single symbol.
  //
  // 'parseType' is the type part of the declaration (to the left)
  // 'arraySizes' is the arrayness tagged on the identifier (to the right)
  //
  void HlslParseContext::declareTypedef(const TSourceLoc& loc, const TString& identifier, const TType& parseType)
  {
      TVariable* typeSymbol = new TVariable(&identifier, parseType, true);
      if (! symbolTable.insert(*typeSymbol))
          error(loc, "name already defined", "typedef", identifier.c_str());
  }
  
  // Do everything necessary to handle a struct declaration, including
  // making IO aliases because HLSL allows mixed IO in a struct that specializes
  // based on the usage (input, output, uniform, none).
  void HlslParseContext::declareStruct(const TSourceLoc& loc, TString& structName, TType& type)
  {
      // If it was named, which means the type can be reused later, add
      // it to the symbol table.  (Unless it's a block, in which
      // case the name is not a type.)
      if (type.getBasicType() == EbtBlock || structName.size() == 0)
          return;
  
      TVariable* userTypeDef = new TVariable(&structName, type, true);
      if (! symbolTable.insert(*userTypeDef)) {
          error(loc, "redefinition", structName.c_str(), "struct");
          return;
      }
  
      // See if we need IO aliases for the structure typeList
  
      const auto condAlloc = [](bool pred, TTypeList*& list) {
          if (pred && list == nullptr)
              list = new TTypeList;
      };
  
      tIoKinds newLists = { nullptr, nullptr, nullptr }; // allocate for each kind found
      for (auto member = type.getStruct()->begin(); member != type.getStruct()->end(); ++member) {
          condAlloc(hasUniform(member->type->getQualifier()), newLists.uniform);
          condAlloc(  hasInput(member->type->getQualifier()), newLists.input);
          condAlloc( hasOutput(member->type->getQualifier()), newLists.output);
  
          if (member->type->isStruct()) {
              auto it = ioTypeMap.find(member->type->getStruct());
              if (it != ioTypeMap.end()) {
                  condAlloc(it->second.uniform != nullptr, newLists.uniform);
                  condAlloc(it->second.input   != nullptr, newLists.input);
                  condAlloc(it->second.output  != nullptr, newLists.output);
              }
          }
      }
      if (newLists.uniform == nullptr &&
          newLists.input   == nullptr &&
          newLists.output  == nullptr) {
          // Won't do any IO caching, clear up the type and get out now.
          for (auto member = type.getStruct()->begin(); member != type.getStruct()->end(); ++member)
              clearUniformInputOutput(member->type->getQualifier());
          return;
      }
  
      // We have IO involved.
  
      // Make a pure typeList for the symbol table, and cache side copies of IO versions.
      for (auto member = type.getStruct()->begin(); member != type.getStruct()->end(); ++member) {
          const auto inheritStruct = [&](TTypeList* s, TTypeLoc& ioMember) {
              if (s != nullptr) {
                  ioMember.type = new TType;
                  ioMember.type->shallowCopy(*member->type);
                  ioMember.type->setStruct(s);
              }
          };
          const auto newMember = [&](TTypeLoc& m) {
              if (m.type == nullptr) {
                  m.type = new TType;
                  m.type->shallowCopy(*member->type);
              }
          };
  
          TTypeLoc newUniformMember = { nullptr, member->loc };
          TTypeLoc newInputMember   = { nullptr, member->loc };
          TTypeLoc newOutputMember  = { nullptr, member->loc };
          if (member->type->isStruct()) {
              // swap in an IO child if there is one
              auto it = ioTypeMap.find(member->type->getStruct());
              if (it != ioTypeMap.end()) {
                  inheritStruct(it->second.uniform, newUniformMember);
                  inheritStruct(it->second.input,   newInputMember);
                  inheritStruct(it->second.output,  newOutputMember);
              }
          }
          if (newLists.uniform) {
              newMember(newUniformMember);
  
              // inherit default matrix layout (changeable via #pragma pack_matrix), if none given.
              if (member->type->isMatrix() && member->type->getQualifier().layoutMatrix == ElmNone)
                  newUniformMember.type->getQualifier().layoutMatrix = globalUniformDefaults.layoutMatrix;
  
              correctUniform(newUniformMember.type->getQualifier());
              newLists.uniform->push_back(newUniformMember);
          }
          if (newLists.input) {
              newMember(newInputMember);
              correctInput(newInputMember.type->getQualifier());
              newLists.input->push_back(newInputMember);
          }
          if (newLists.output) {
              newMember(newOutputMember);
              correctOutput(newOutputMember.type->getQualifier());
              newLists.output->push_back(newOutputMember);
          }
  
          // make original pure
          clearUniformInputOutput(member->type->getQualifier());
      }
      ioTypeMap[type.getStruct()] = newLists;
  }
  
  // Lookup a user-type by name.
  // If found, fill in the type and return the defining symbol.
  // If not found, return nullptr.
  TSymbol* HlslParseContext::lookupUserType(const TString& typeName, TType& type)
  {
      TSymbol* symbol = symbolTable.find(typeName);
      if (symbol && symbol->getAsVariable() && symbol->getAsVariable()->isUserType()) {
          type.shallowCopy(symbol->getType());
          return symbol;
      } else
          return nullptr;
  }
  
  //
  // Do everything necessary to handle a variable (non-block) declaration.
  // Either redeclaring a variable, or making a new one, updating the symbol
  // table, and all error checking.
  //
  // Returns a subtree node that computes an initializer, if needed.
  // Returns nullptr if there is no code to execute for initialization.
  //
  // 'parseType' is the type part of the declaration (to the left)
  // 'arraySizes' is the arrayness tagged on the identifier (to the right)
  //
  TIntermNode* HlslParseContext::declareVariable(const TSourceLoc& loc, const TString& identifier, TType& type,
                                                 TIntermTyped* initializer)
  {
      if (voidErrorCheck(loc, identifier, type.getBasicType()))
          return nullptr;
  
      // Global consts with initializers that are non-const act like EvqGlobal in HLSL.
      // This test is implicitly recursive, because initializers propagate constness
      // up the aggregate node tree during creation.  E.g, for:
      //    { { 1, 2 }, { 3, 4 } }
      // the initializer list is marked EvqConst at the top node, and remains so here.  However:
      //    { 1, { myvar, 2 }, 3 }
      // is not a const intializer, and still becomes EvqGlobal here.
  
      const bool nonConstInitializer = (initializer != nullptr && initializer->getQualifier().storage != EvqConst);
  
      if (type.getQualifier().storage == EvqConst && symbolTable.atGlobalLevel() && nonConstInitializer) {
          // Force to global
          type.getQualifier().storage = EvqGlobal;
      }
  
      // make const and initialization consistent
      fixConstInit(loc, identifier, type, initializer);
  
      // Check for redeclaration of built-ins and/or attempting to declare a reserved name
      TSymbol* symbol = nullptr;
  
      inheritGlobalDefaults(type.getQualifier());
  
      const bool flattenVar = shouldFlatten(type, type.getQualifier().storage, true);
  
      // correct IO in the type
      switch (type.getQualifier().storage) {
      case EvqGlobal:
      case EvqTemporary:
          clearUniformInputOutput(type.getQualifier());
          break;
      case EvqUniform:
      case EvqBuffer:
          correctUniform(type.getQualifier());
          if (type.isStruct()) {
              auto it = ioTypeMap.find(type.getStruct());
              if (it != ioTypeMap.end())
                  type.setStruct(it->second.uniform);
          }
  
          break;
      default:
          break;
      }
  
      // Declare the variable
      if (type.isArray()) {
          // array case
          declareArray(loc, identifier, type, symbol, !flattenVar);
      } else {
          // non-array case
          if (symbol == nullptr)
              symbol = declareNonArray(loc, identifier, type, !flattenVar);
          else if (type != symbol->getType())
              error(loc, "cannot change the type of", "redeclaration", symbol->getName().c_str());
      }
  
      if (symbol == nullptr)
          return nullptr;
  
      if (flattenVar)
          flatten(*symbol->getAsVariable(), symbolTable.atGlobalLevel());
  
      if (initializer == nullptr)
          return nullptr;
  
      // Deal with initializer
      TVariable* variable = symbol->getAsVariable();
      if (variable == nullptr) {
          error(loc, "initializer requires a variable, not a member", identifier.c_str(), "");
          return nullptr;
      }
      return executeInitializer(loc, initializer, variable);
  }
  
  // Pick up global defaults from the provide global defaults into dst.
  void HlslParseContext::inheritGlobalDefaults(TQualifier& dst) const
  {
      if (dst.storage == EvqVaryingOut) {
          if (! dst.hasStream() && language == EShLangGeometry)
              dst.layoutStream = globalOutputDefaults.layoutStream;
          if (! dst.hasXfbBuffer())
              dst.layoutXfbBuffer = globalOutputDefaults.layoutXfbBuffer;
      }
  }
  
  //
  // Make an internal-only variable whose name is for debug purposes only
  // and won't be searched for.  Callers will only use the return value to use
  // the variable, not the name to look it up.  It is okay if the name
  // is the same as other names; there won't be any conflict.
  //
  TVariable* HlslParseContext::makeInternalVariable(const char* name, const TType& type) const
  {
      TString* nameString = NewPoolTString(name);
      TVariable* variable = new TVariable(nameString, type);
      symbolTable.makeInternalVariable(*variable);
  
      return variable;
  }
  
  // Make a symbol node holding a new internal temporary variable.
  TIntermSymbol* HlslParseContext::makeInternalVariableNode(const TSourceLoc& loc, const char* name,
                                                            const TType& type) const
  {
      TVariable* tmpVar = makeInternalVariable(name, type);
      tmpVar->getWritableType().getQualifier().makeTemporary();
  
      return intermediate.addSymbol(*tmpVar, loc);
  }
  
  //
  // Declare a non-array variable, the main point being there is no redeclaration
  // for resizing allowed.
  //
  // Return the successfully declared variable.
  //
  TVariable* HlslParseContext::declareNonArray(const TSourceLoc& loc, const TString& identifier, const TType& type,
                                               bool track)
  {
      // make a new variable
      TVariable* variable = new TVariable(&identifier, type);
  
      // add variable to symbol table
      if (symbolTable.insert(*variable)) {
          if (track && symbolTable.atGlobalLevel())
              trackLinkage(*variable);
          return variable;
      }
  
      error(loc, "redefinition", variable->getName().c_str(), "");
      return nullptr;
  }
  
  //
  // Handle all types of initializers from the grammar.
  //
  // Returning nullptr just means there is no code to execute to handle the
  // initializer, which will, for example, be the case for constant initializers.
  //
  // Returns a subtree that accomplished the initialization.
  //
  TIntermNode* HlslParseContext::executeInitializer(const TSourceLoc& loc, TIntermTyped* initializer, TVariable* variable)
  {
      //
      // Identifier must be of type constant, a global, or a temporary, and
      // starting at version 120, desktop allows uniforms to have initializers.
      //
      TStorageQualifier qualifier = variable->getType().getQualifier().storage;
  
      //
      // If the initializer was from braces { ... }, we convert the whole subtree to a
      // constructor-style subtree, allowing the rest of the code to operate
      // identically for both kinds of initializers.
      //
      //
      // Type can't be deduced from the initializer list, so a skeletal type to
      // follow has to be passed in.  Constness and specialization-constness
      // should be deduced bottom up, not dictated by the skeletal type.
      //
      TType skeletalType;
      skeletalType.shallowCopy(variable->getType());
      skeletalType.getQualifier().makeTemporary();
      if (initializer->getAsAggregate() && initializer->getAsAggregate()->getOp() == EOpNull)
          initializer = convertInitializerList(loc, skeletalType, initializer, nullptr);
      if (initializer == nullptr) {
          // error recovery; don't leave const without constant values
          if (qualifier == EvqConst)
              variable->getWritableType().getQualifier().storage = EvqTemporary;
          return nullptr;
      }
  
      // Fix outer arrayness if variable is unsized, getting size from the initializer
      if (initializer->getType().isSizedArray() && variable->getType().isUnsizedArray())
          variable->getWritableType().changeOuterArraySize(initializer->getType().getOuterArraySize());
  
      // Inner arrayness can also get set by an initializer
      if (initializer->getType().isArrayOfArrays() && variable->getType().isArrayOfArrays() &&
          initializer->getType().getArraySizes()->getNumDims() ==
          variable->getType().getArraySizes()->getNumDims()) {
          // adopt unsized sizes from the initializer's sizes
          for (int d = 1; d < variable->getType().getArraySizes()->getNumDims(); ++d) {
              if (variable->getType().getArraySizes()->getDimSize(d) == UnsizedArraySize) {
                  variable->getWritableType().getArraySizes()->setDimSize(d,
                      initializer->getType().getArraySizes()->getDimSize(d));
              }
          }
      }
  
      // Uniform and global consts require a constant initializer
      if (qualifier == EvqUniform && initializer->getType().getQualifier().storage != EvqConst) {
          error(loc, "uniform initializers must be constant", "=", "'%s'", variable->getType().getCompleteString().c_str());
          variable->getWritableType().getQualifier().storage = EvqTemporary;
          return nullptr;
      }
  
      // Const variables require a constant initializer
      if (qualifier == EvqConst) {
          if (initializer->getType().getQualifier().storage != EvqConst) {
              variable->getWritableType().getQualifier().storage = EvqConstReadOnly;
              qualifier = EvqConstReadOnly;
          }
      }
  
      if (qualifier == EvqConst || qualifier == EvqUniform) {
          // Compile-time tagging of the variable with its constant value...
  
          initializer = intermediate.addConversion(EOpAssign, variable->getType(), initializer);
          if (initializer != nullptr && variable->getType() != initializer->getType())
              initializer = intermediate.addUniShapeConversion(EOpAssign, variable->getType(), initializer);
          if (initializer == nullptr || !initializer->getAsConstantUnion() ||
                                        variable->getType() != initializer->getType()) {
              error(loc, "non-matching or non-convertible constant type for const initializer",
                  variable->getType().getStorageQualifierString(), "");
              variable->getWritableType().getQualifier().storage = EvqTemporary;
              return nullptr;
          }
  
          variable->setConstArray(initializer->getAsConstantUnion()->getConstArray());
      } else {
          // normal assigning of a value to a variable...
          specializationCheck(loc, initializer->getType(), "initializer");
          TIntermSymbol* intermSymbol = intermediate.addSymbol(*variable, loc);
          TIntermNode* initNode = handleAssign(loc, EOpAssign, intermSymbol, initializer);
          if (initNode == nullptr)
              assignError(loc, "=", intermSymbol->getCompleteString(), initializer->getCompleteString());
          return initNode;
      }
  
      return nullptr;
  }
  
  //
  // Reprocess any initializer-list { ... } parts of the initializer.
  // Need to hierarchically assign correct types and implicit
  // conversions. Will do this mimicking the same process used for
  // creating a constructor-style initializer, ensuring we get the
  // same form.
  //
  // Returns a node representing an expression for the initializer list expressed
  // as the correct type.
  //
  // Returns nullptr if there is an error.
  //
  TIntermTyped* HlslParseContext::convertInitializerList(const TSourceLoc& loc, const TType& type,
                                                         TIntermTyped* initializer, TIntermTyped* scalarInit)
  {
      // Will operate recursively.  Once a subtree is found that is constructor style,
      // everything below it is already good: Only the "top part" of the initializer
      // can be an initializer list, where "top part" can extend for several (or all) levels.
  
      // see if we have bottomed out in the tree within the initializer-list part
      TIntermAggregate* initList = initializer->getAsAggregate();
      if (initList == nullptr || initList->getOp() != EOpNull) {
          // We don't have a list, but if it's a scalar and the 'type' is a
          // composite, we need to lengthen below to make it useful.
          // Otherwise, this is an already formed object to initialize with.
          if (type.isScalar() || !initializer->getType().isScalar())
              return initializer;
          else
              initList = intermediate.makeAggregate(initializer);
      }
  
      // Of the initializer-list set of nodes, need to process bottom up,
      // so recurse deep, then process on the way up.
  
      // Go down the tree here...
      if (type.isArray()) {
          // The type's array might be unsized, which could be okay, so base sizes on the size of the aggregate.
          // Later on, initializer execution code will deal with array size logic.
          TType arrayType;
          arrayType.shallowCopy(type);                     // sharing struct stuff is fine
          arrayType.copyArraySizes(*type.getArraySizes()); // but get a fresh copy of the array information, to edit below
  
          // edit array sizes to fill in unsized dimensions
          if (type.isUnsizedArray())
              arrayType.changeOuterArraySize((int)initList->getSequence().size());
  
          // set unsized array dimensions that can be derived from the initializer's first element
          if (arrayType.isArrayOfArrays() && initList->getSequence().size() > 0) {
              TIntermTyped* firstInit = initList->getSequence()[0]->getAsTyped();
              if (firstInit->getType().isArray() &&
                  arrayType.getArraySizes()->getNumDims() == firstInit->getType().getArraySizes()->getNumDims() + 1) {
                  for (int d = 1; d < arrayType.getArraySizes()->getNumDims(); ++d) {
                      if (arrayType.getArraySizes()->getDimSize(d) == UnsizedArraySize)
                          arrayType.getArraySizes()->setDimSize(d, firstInit->getType().getArraySizes()->getDimSize(d - 1));
                  }
              }
          }
  
          // lengthen list to be long enough
          lengthenList(loc, initList->getSequence(), arrayType.getOuterArraySize(), scalarInit);
  
          // recursively process each element
          TType elementType(arrayType, 0); // dereferenced type
          for (int i = 0; i < arrayType.getOuterArraySize(); ++i) {
              initList->getSequence()[i] = convertInitializerList(loc, elementType,
                                                                  initList->getSequence()[i]->getAsTyped(), scalarInit);
              if (initList->getSequence()[i] == nullptr)
                  return nullptr;
          }
  
          return addConstructor(loc, initList, arrayType);
      } else if (type.isStruct()) {
          // do we have implicit assignments to opaques?
          for (size_t i = initList->getSequence().size(); i < type.getStruct()->size(); ++i) {
              if ((*type.getStruct())[i].type->containsOpaque()) {
                  error(loc, "cannot implicitly initialize opaque members", "initializer list", "");
                  return nullptr;
              }
          }
  
          // lengthen list to be long enough
          lengthenList(loc, initList->getSequence(), static_cast<int>(type.getStruct()->size()), scalarInit);
  
          if (type.getStruct()->size() != initList->getSequence().size()) {
              error(loc, "wrong number of structure members", "initializer list", "");
              return nullptr;
          }
          for (size_t i = 0; i < type.getStruct()->size(); ++i) {
              initList->getSequence()[i] = convertInitializerList(loc, *(*type.getStruct())[i].type,
                                                                  initList->getSequence()[i]->getAsTyped(), scalarInit);
              if (initList->getSequence()[i] == nullptr)
                  return nullptr;
          }
      } else if (type.isMatrix()) {
          if (type.computeNumComponents() == (int)initList->getSequence().size()) {
              // This means the matrix is initialized component-wise, rather than as
              // a series of rows and columns.  We can just use the list directly as
              // a constructor; no further processing needed.
          } else {
              // lengthen list to be long enough
              lengthenList(loc, initList->getSequence(), type.getMatrixCols(), scalarInit);
  
              if (type.getMatrixCols() != (int)initList->getSequence().size()) {
                  error(loc, "wrong number of matrix columns:", "initializer list", type.getCompleteString().c_str());
                  return nullptr;
              }
              TType vectorType(type, 0); // dereferenced type
              for (int i = 0; i < type.getMatrixCols(); ++i) {
                  initList->getSequence()[i] = convertInitializerList(loc, vectorType,
                                                                      initList->getSequence()[i]->getAsTyped(), scalarInit);
                  if (initList->getSequence()[i] == nullptr)
                      return nullptr;
              }
          }
      } else if (type.isVector()) {
          // lengthen list to be long enough
          lengthenList(loc, initList->getSequence(), type.getVectorSize(), scalarInit);
  
          // error check; we're at bottom, so work is finished below
          if (type.getVectorSize() != (int)initList->getSequence().size()) {
              error(loc, "wrong vector size (or rows in a matrix column):", "initializer list",
                    type.getCompleteString().c_str());
              return nullptr;
          }
      } else if (type.isScalar()) {
          // lengthen list to be long enough
          lengthenList(loc, initList->getSequence(), 1, scalarInit);
  
          if ((int)initList->getSequence().size() != 1) {
              error(loc, "scalar expected one element:", "initializer list", type.getCompleteString().c_str());
              return nullptr;
          }
      } else {
          error(loc, "unexpected initializer-list type:", "initializer list", type.getCompleteString().c_str());
          return nullptr;
      }
  
      // Now that the subtree is processed, process this node as if the
      // initializer list is a set of arguments to a constructor.
      TIntermTyped* emulatedConstructorArguments;
      if (initList->getSequence().size() == 1)
          emulatedConstructorArguments = initList->getSequence()[0]->getAsTyped();
      else
          emulatedConstructorArguments = initList;
  
      return addConstructor(loc, emulatedConstructorArguments, type);
  }
  
  // Lengthen list to be long enough to cover any gap from the current list size
  // to 'size'. If the list is longer, do nothing.
  // The value to lengthen with is the default for short lists.
  //
  // By default, lists that are too short due to lack of initializers initialize to zero.
  // Alternatively, it could be a scalar initializer for a structure. Both cases are handled,
  // based on whether something is passed in as 'scalarInit'.
  //
  // 'scalarInit' must be safe to use each time this is called (no side effects replication).
  //
  void HlslParseContext::lengthenList(const TSourceLoc& loc, TIntermSequence& list, int size, TIntermTyped* scalarInit)
  {
      for (int c = (int)list.size(); c < size; ++c) {
          if (scalarInit == nullptr)
              list.push_back(intermediate.addConstantUnion(0, loc));
          else
              list.push_back(scalarInit);
      }
  }
  
  //
  // Test for the correctness of the parameters passed to various constructor functions
  // and also convert them to the right data type, if allowed and required.
  //
  // Returns nullptr for an error or the constructed node (aggregate or typed) for no error.
  //
  TIntermTyped* HlslParseContext::handleConstructor(const TSourceLoc& loc, TIntermTyped* node, const TType& type)
  {
      if (node == nullptr)
          return nullptr;
  
      // Construct identical type
      if (type == node->getType())
          return node;
  
      // Handle the idiom "(struct type)<scalar value>"
      if (type.isStruct() && isScalarConstructor(node)) {
          // 'node' will almost always get used multiple times, so should not be used directly,
          // it would create a DAG instead of a tree, which might be okay (would
          // like to formalize that for constants and symbols), but if it has
          // side effects, they would get executed multiple times, which is not okay.
          if (node->getAsConstantUnion() == nullptr && node->getAsSymbolNode() == nullptr) {
              TIntermAggregate* seq = intermediate.makeAggregate(loc);
              TIntermSymbol* copy = makeInternalVariableNode(loc, "scalarCopy", node->getType());
              seq = intermediate.growAggregate(seq, intermediate.addBinaryNode(EOpAssign, copy, node, loc));
              seq = intermediate.growAggregate(seq, convertInitializerList(loc, type, intermediate.makeAggregate(loc), copy));
              seq->setOp(EOpComma);
              seq->setType(type);
              return seq;
          } else
              return convertInitializerList(loc, type, intermediate.makeAggregate(loc), node);
      }
  
      return addConstructor(loc, node, type);
  }
  
  // Add a constructor, either from the grammar, or other programmatic reasons.
  //
  // 'node' is what to construct from.
  // 'type' is what type to construct.
  //
  // Returns the constructed object.
  // Return nullptr if it can't be done.
  //
  TIntermTyped* HlslParseContext::addConstructor(const TSourceLoc& loc, TIntermTyped* node, const TType& type)
  {
      TIntermAggregate* aggrNode = node->getAsAggregate();
      TOperator op = intermediate.mapTypeToConstructorOp(type);
  
      if (op == EOpConstructTextureSampler)
          return intermediate.setAggregateOperator(aggrNode, op, type, loc);
  
      TTypeList::const_iterator memberTypes;
      if (op == EOpConstructStruct)
          memberTypes = type.getStruct()->begin();
  
      TType elementType;
      if (type.isArray()) {
          TType dereferenced(type, 0);
          elementType.shallowCopy(dereferenced);
      } else
          elementType.shallowCopy(type);
  
      bool singleArg;
      if (aggrNode != nullptr) {
          if (aggrNode->getOp() != EOpNull)
              singleArg = true;
          else
              singleArg = false;
      } else
          singleArg = true;
  
      TIntermTyped *newNode;
      if (singleArg) {
          // Handle array -> array conversion
          // Constructing an array of one type from an array of another type is allowed,
          // assuming there are enough components available (semantic-checked earlier).
          if (type.isArray() && node->isArray())
              newNode = convertArray(node, type);
  
          // If structure constructor or array constructor is being called
          // for only one parameter inside the aggregate, we need to call constructAggregate function once.
          else if (type.isArray())
              newNode = constructAggregate(node, elementType, 1, node->getLoc());
          else if (op == EOpConstructStruct)
              newNode = constructAggregate(node, *(*memberTypes).type, 1, node->getLoc());
          else {
              // shape conversion for matrix constructor from scalar.  HLSL semantics are: scalar
              // is replicated into every element of the matrix (not just the diagnonal), so
              // that is handled specially here.
              if (type.isMatrix() && node->getType().isScalarOrVec1())
                  node = intermediate.addShapeConversion(type, node);
  
              newNode = constructBuiltIn(type, op, node, node->getLoc(), false);
          }
  
          if (newNode && (type.isArray() || op == EOpConstructStruct))
              newNode = intermediate.setAggregateOperator(newNode, EOpConstructStruct, type, loc);
  
          return newNode;
      }
  
      //
      // Handle list of arguments.
      //
      TIntermSequence& sequenceVector = aggrNode->getSequence();    // Stores the information about the parameter to the constructor
      // if the structure constructor contains more than one parameter, then construct
      // each parameter
  
      int paramCount = 0;  // keeps a track of the constructor parameter number being checked
  
      // for each parameter to the constructor call, check to see if the right type is passed or convert them
      // to the right type if possible (and allowed).
      // for structure constructors, just check if the right type is passed, no conversion is allowed.
  
      for (TIntermSequence::iterator p = sequenceVector.begin();
          p != sequenceVector.end(); p++, paramCount++) {
          if (type.isArray())
              newNode = constructAggregate(*p, elementType, paramCount + 1, node->getLoc());
          else if (op == EOpConstructStruct)
              newNode = constructAggregate(*p, *(memberTypes[paramCount]).type, paramCount + 1, node->getLoc());
          else
              newNode = constructBuiltIn(type, op, (*p)->getAsTyped(), node->getLoc(), true);
  
          if (newNode)
              *p = newNode;
          else
              return nullptr;
      }
  
      TIntermTyped* constructor = intermediate.setAggregateOperator(aggrNode, op, type, loc);
  
      return constructor;
  }
  
  // Function for constructor implementation. Calls addUnaryMath with appropriate EOp value
  // for the parameter to the constructor (passed to this function). Essentially, it converts
  // the parameter types correctly. If a constructor expects an int (like ivec2) and is passed a
  // float, then float is converted to int.
  //
  // Returns nullptr for an error or the constructed node.
  //
  TIntermTyped* HlslParseContext::constructBuiltIn(const TType& type, TOperator op, TIntermTyped* node,
                                                   const TSourceLoc& loc, bool subset)
  {
      TIntermTyped* newNode;
      TOperator basicOp;
  
      //
      // First, convert types as needed.
      //
      switch (op) {
      case EOpConstructF16Vec2:
      case EOpConstructF16Vec3:
      case EOpConstructF16Vec4:
      case EOpConstructF16Mat2x2:
      case EOpConstructF16Mat2x3:
      case EOpConstructF16Mat2x4:
      case EOpConstructF16Mat3x2:
      case EOpConstructF16Mat3x3:
      case EOpConstructF16Mat3x4:
      case EOpConstructF16Mat4x2:
      case EOpConstructF16Mat4x3:
      case EOpConstructF16Mat4x4:
      case EOpConstructFloat16:
          basicOp = EOpConstructFloat16;
          break;
  
      case EOpConstructVec2:
      case EOpConstructVec3:
      case EOpConstructVec4:
      case EOpConstructMat2x2:
      case EOpConstructMat2x3:
      case EOpConstructMat2x4:
      case EOpConstructMat3x2:
      case EOpConstructMat3x3:
      case EOpConstructMat3x4:
      case EOpConstructMat4x2:
      case EOpConstructMat4x3:
      case EOpConstructMat4x4:
      case EOpConstructFloat:
          basicOp = EOpConstructFloat;
          break;
  
      case EOpConstructDVec2:
      case EOpConstructDVec3:
      case EOpConstructDVec4:
      case EOpConstructDMat2x2:
      case EOpConstructDMat2x3:
      case EOpConstructDMat2x4:
      case EOpConstructDMat3x2:
      case EOpConstructDMat3x3:
      case EOpConstructDMat3x4:
      case EOpConstructDMat4x2:
      case EOpConstructDMat4x3:
      case EOpConstructDMat4x4:
      case EOpConstructDouble:
          basicOp = EOpConstructDouble;
          break;
  
      case EOpConstructI16Vec2:
      case EOpConstructI16Vec3:
      case EOpConstructI16Vec4:
      case EOpConstructInt16:
          basicOp = EOpConstructInt16;
          break;
  
      case EOpConstructIVec2:
      case EOpConstructIVec3:
      case EOpConstructIVec4:
      case EOpConstructIMat2x2:
      case EOpConstructIMat2x3:
      case EOpConstructIMat2x4:
      case EOpConstructIMat3x2:
      case EOpConstructIMat3x3:
      case EOpConstructIMat3x4:
      case EOpConstructIMat4x2:
      case EOpConstructIMat4x3:
      case EOpConstructIMat4x4:
      case EOpConstructInt:
          basicOp = EOpConstructInt;
          break;
  
      case EOpConstructU16Vec2:
      case EOpConstructU16Vec3:
      case EOpConstructU16Vec4:
      case EOpConstructUint16:
          basicOp = EOpConstructUint16;
          break;
  
      case EOpConstructUVec2:
      case EOpConstructUVec3:
      case EOpConstructUVec4:
      case EOpConstructUMat2x2:
      case EOpConstructUMat2x3:
      case EOpConstructUMat2x4:
      case EOpConstructUMat3x2:
      case EOpConstructUMat3x3:
      case EOpConstructUMat3x4:
      case EOpConstructUMat4x2:
      case EOpConstructUMat4x3:
      case EOpConstructUMat4x4:
      case EOpConstructUint:
          basicOp = EOpConstructUint;
          break;
  
      case EOpConstructBVec2:
      case EOpConstructBVec3:
      case EOpConstructBVec4:
      case EOpConstructBMat2x2:
      case EOpConstructBMat2x3:
      case EOpConstructBMat2x4:
      case EOpConstructBMat3x2:
      case EOpConstructBMat3x3:
      case EOpConstructBMat3x4:
      case EOpConstructBMat4x2:
      case EOpConstructBMat4x3:
      case EOpConstructBMat4x4:
      case EOpConstructBool:
          basicOp = EOpConstructBool;
          break;
  
      default:
          error(loc, "unsupported construction", "", "");
  
          return nullptr;
      }
      newNode = intermediate.addUnaryMath(basicOp, node, node->getLoc());
      if (newNode == nullptr) {
          error(loc, "can't convert", "constructor", "");
          return nullptr;
      }
  
      //
      // Now, if there still isn't an operation to do the construction, and we need one, add one.
      //
  
      // Otherwise, skip out early.
      if (subset || (newNode != node && newNode->getType() == type))
          return newNode;
  
      // setAggregateOperator will insert a new node for the constructor, as needed.
      return intermediate.setAggregateOperator(newNode, op, type, loc);
  }
  
  // Convert the array in node to the requested type, which is also an array.
  // Returns nullptr on failure, otherwise returns aggregate holding the list of
  // elements needed to construct the array.
  TIntermTyped* HlslParseContext::convertArray(TIntermTyped* node, const TType& type)
  {
      assert(node->isArray() && type.isArray());
      if (node->getType().computeNumComponents() < type.computeNumComponents())
          return nullptr;
  
      // TODO: write an argument replicator, for the case the argument should not be
      // executed multiple times, yet multiple copies are needed.
  
      TIntermTyped* constructee = node->getAsTyped();
      // track where we are in consuming the argument
      int constructeeElement = 0;
      int constructeeComponent = 0;
  
      // bump up to the next component to consume
      const auto getNextComponent = [&]() {
          TIntermTyped* component;
          component = handleBracketDereference(node->getLoc(), constructee, 
                                               intermediate.addConstantUnion(constructeeElement, node->getLoc()));
          if (component->isVector())
              component = handleBracketDereference(node->getLoc(), component,
                                                   intermediate.addConstantUnion(constructeeComponent, node->getLoc()));
          // bump component pointer up
          ++constructeeComponent;
          if (constructeeComponent == constructee->getVectorSize()) {
              constructeeComponent = 0;
              ++constructeeElement;
          }
          return component;
      };
  
      // make one subnode per constructed array element
      TIntermAggregate* constructor = nullptr;
      TType derefType(type, 0);
      TType speculativeComponentType(derefType, 0);
      TType* componentType = derefType.isVector() ? &speculativeComponentType : &derefType;
      TOperator componentOp = intermediate.mapTypeToConstructorOp(*componentType);
      TType crossType(node->getBasicType(), EvqTemporary, type.getVectorSize());
      for (int e = 0; e < type.getOuterArraySize(); ++e) {
          // construct an element
          TIntermTyped* elementArg;
          if (type.getVectorSize() == constructee->getVectorSize()) {
              // same element shape
              elementArg = handleBracketDereference(node->getLoc(), constructee,
                                                    intermediate.addConstantUnion(e, node->getLoc()));
          } else {
              // mismatched element shapes
              if (type.getVectorSize() == 1)
                  elementArg = getNextComponent();
              else {
                  // make a vector
                  TIntermAggregate* elementConstructee = nullptr;
                  for (int c = 0; c < type.getVectorSize(); ++c)
                      elementConstructee = intermediate.growAggregate(elementConstructee, getNextComponent());
                  elementArg = addConstructor(node->getLoc(), elementConstructee, crossType);
              }
          }
          // convert basic types
          elementArg = intermediate.addConversion(componentOp, derefType, elementArg);
          if (elementArg == nullptr)
              return nullptr;
          // combine with top-level constructor
          constructor = intermediate.growAggregate(constructor, elementArg);
      }
  
      return constructor;
  }
  
  // This function tests for the type of the parameters to the structure or array constructor. Raises
  // an error message if the expected type does not match the parameter passed to the constructor.
  //
  // Returns nullptr for an error or the input node itself if the expected and the given parameter types match.
  //
  TIntermTyped* HlslParseContext::constructAggregate(TIntermNode* node, const TType& type, int paramCount,
                                                     const TSourceLoc& loc)
  {
      // Handle cases that map more 1:1 between constructor arguments and constructed.
      TIntermTyped* converted = intermediate.addConversion(EOpConstructStruct, type, node->getAsTyped());
      if (converted == nullptr || converted->getType() != type) {
          error(loc, "", "constructor", "cannot convert parameter %d from '%s' to '%s'", paramCount,
              node->getAsTyped()->getType().getCompleteString().c_str(), type.getCompleteString().c_str());
  
          return nullptr;
      }
  
      return converted;
  }
  
  //
  // Do everything needed to add an interface block.
  //
  void HlslParseContext::declareBlock(const TSourceLoc& loc, TType& type, const TString* instanceName)
  {
      assert(type.getWritableStruct() != nullptr);
  
      // Clean up top-level decorations that don't belong.
      switch (type.getQualifier().storage) {
      case EvqUniform:
      case EvqBuffer:
          correctUniform(type.getQualifier());
          break;
      case EvqVaryingIn:
          correctInput(type.getQualifier());
          break;
      case EvqVaryingOut:
          correctOutput(type.getQualifier());
          break;
      default:
          break;
      }
  
      TTypeList& typeList = *type.getWritableStruct();
      // fix and check for member storage qualifiers and types that don't belong within a block
      for (unsigned int member = 0; member < typeList.size(); ++member) {
          TType& memberType = *typeList[member].type;
          TQualifier& memberQualifier = memberType.getQualifier();
          const TSourceLoc& memberLoc = typeList[member].loc;
          globalQualifierFix(memberLoc, memberQualifier);
          memberQualifier.storage = type.getQualifier().storage;
  
          if (memberType.isStruct()) {
              // clean up and pick up the right set of decorations
              auto it = ioTypeMap.find(memberType.getStruct());
              switch (type.getQualifier().storage) {
              case EvqUniform:
              case EvqBuffer:
                  correctUniform(type.getQualifier());
                  if (it != ioTypeMap.end() && it->second.uniform)
                      memberType.setStruct(it->second.uniform);
                  break;
              case EvqVaryingIn:
                  correctInput(type.getQualifier());
                  if (it != ioTypeMap.end() && it->second.input)
                      memberType.setStruct(it->second.input);
                  break;
              case EvqVaryingOut:
                  correctOutput(type.getQualifier());
                  if (it != ioTypeMap.end() && it->second.output)
                      memberType.setStruct(it->second.output);
                  break;
              default:
                  break;
              }
          }
      }
  
      // Make default block qualification, and adjust the member qualifications
  
      TQualifier defaultQualification;
      switch (type.getQualifier().storage) {
      case EvqUniform:    defaultQualification = globalUniformDefaults;    break;
      case EvqBuffer:     defaultQualification = globalBufferDefaults;     break;
      case EvqVaryingIn:  defaultQualification = globalInputDefaults;      break;
      case EvqVaryingOut: defaultQualification = globalOutputDefaults;     break;
      default:            defaultQualification.clear();                    break;
      }
  
      // Special case for "push_constant uniform", which has a default of std430,
      // contrary to normal uniform defaults, and can't have a default tracked for it.
      if (type.getQualifier().layoutPushConstant && ! type.getQualifier().hasPacking())
          type.getQualifier().layoutPacking = ElpStd430;
  
      // fix and check for member layout qualifiers
  
      mergeObjectLayoutQualifiers(defaultQualification, type.getQualifier(), true);
  
      bool memberWithLocation = false;
      bool memberWithoutLocation = false;
      for (unsigned int member = 0; member < typeList.size(); ++member) {
          TQualifier& memberQualifier = typeList[member].type->getQualifier();
          const TSourceLoc& memberLoc = typeList[member].loc;
          if (memberQualifier.hasStream()) {
              if (defaultQualification.layoutStream != memberQualifier.layoutStream)
                  error(memberLoc, "member cannot contradict block", "stream", "");
          }
  
          // "This includes a block's inheritance of the
          // current global default buffer, a block member's inheritance of the block's
          // buffer, and the requirement that any *xfb_buffer* declared on a block
          // member must match the buffer inherited from the block."
          if (memberQualifier.hasXfbBuffer()) {
              if (defaultQualification.layoutXfbBuffer != memberQualifier.layoutXfbBuffer)
                  error(memberLoc, "member cannot contradict block (or what block inherited from global)", "xfb_buffer", "");
          }
  
          if (memberQualifier.hasLocation()) {
              switch (type.getQualifier().storage) {
              case EvqVaryingIn:
              case EvqVaryingOut:
                  memberWithLocation = true;
                  break;
              default:
                  break;
              }
          } else
              memberWithoutLocation = true;
  
          TQualifier newMemberQualification = defaultQualification;
          mergeQualifiers(newMemberQualification, memberQualifier);
          memberQualifier = newMemberQualification;
      }
  
      // Process the members
      fixBlockLocations(loc, type.getQualifier(), typeList, memberWithLocation, memberWithoutLocation);
      fixXfbOffsets(type.getQualifier(), typeList);
      fixBlockUniformOffsets(type.getQualifier(), typeList);
  
      // reverse merge, so that currentBlockQualifier now has all layout information
      // (can't use defaultQualification directly, it's missing other non-layout-default-class qualifiers)
      mergeObjectLayoutQualifiers(type.getQualifier(), defaultQualification, true);
  
      //
      // Build and add the interface block as a new type named 'blockName'
      //
  
      // Use the instance name as the interface name if one exists, else the block name.
      const TString& interfaceName = (instanceName && !instanceName->empty()) ? *instanceName : type.getTypeName();
  
      TType blockType(&typeList, interfaceName, type.getQualifier());
      if (type.isArray())
          blockType.transferArraySizes(type.getArraySizes());
  
      // Add the variable, as anonymous or named instanceName.
      // Make an anonymous variable if no name was provided.
      if (instanceName == nullptr)
          instanceName = NewPoolTString("");
  
      TVariable& variable = *new TVariable(instanceName, blockType);
      if (! symbolTable.insert(variable)) {
          if (*instanceName == "")
              error(loc, "nameless block contains a member that already has a name at global scope",
                    "" /* blockName->c_str() */, "");
          else
              error(loc, "block instance name redefinition", variable.getName().c_str(), "");
  
          return;
      }
  
      // Save it in the AST for linker use.
      if (symbolTable.atGlobalLevel())
          trackLinkage(variable);
  }
  
  //
  // "For a block, this process applies to the entire block, or until the first member
  // is reached that has a location layout qualifier. When a block member is declared with a location
  // qualifier, its location comes from that qualifier: The member's location qualifier overrides the block-level
  // declaration. Subsequent members are again assigned consecutive locations, based on the newest location,
  // until the next member declared with a location qualifier. The values used for locations do not have to be
  // declared in increasing order."
  void HlslParseContext::fixBlockLocations(const TSourceLoc& loc, TQualifier& qualifier, TTypeList& typeList, bool memberWithLocation, bool memberWithoutLocation)
  {
      // "If a block has no block-level location layout qualifier, it is required that either all or none of its members
      // have a location layout qualifier, or a compile-time error results."
      if (! qualifier.hasLocation() && memberWithLocation && memberWithoutLocation)
          error(loc, "either the block needs a location, or all members need a location, or no members have a location", "location", "");
      else {
          if (memberWithLocation) {
              // remove any block-level location and make it per *every* member
              int nextLocation = 0;  // by the rule above, initial value is not relevant
              if (qualifier.hasAnyLocation()) {
                  nextLocation = qualifier.layoutLocation;
                  qualifier.layoutLocation = TQualifier::layoutLocationEnd;
                  if (qualifier.hasComponent()) {
                      // "It is a compile-time error to apply the *component* qualifier to a ... block"
                      error(loc, "cannot apply to a block", "component", "");
                  }
                  if (qualifier.hasIndex()) {
                      error(loc, "cannot apply to a block", "index", "");
                  }
              }
              for (unsigned int member = 0; member < typeList.size(); ++member) {
                  TQualifier& memberQualifier = typeList[member].type->getQualifier();
                  const TSourceLoc& memberLoc = typeList[member].loc;
                  if (! memberQualifier.hasLocation()) {
                      if (nextLocation >= (int)TQualifier::layoutLocationEnd)
                          error(memberLoc, "location is too large", "location", "");
                      memberQualifier.layoutLocation = nextLocation;
                      memberQualifier.layoutComponent = 0;
                  }
                  nextLocation = memberQualifier.layoutLocation +
                                 intermediate.computeTypeLocationSize(*typeList[member].type, language);
              }
          }
      }
  }
  
  void HlslParseContext::fixXfbOffsets(TQualifier& qualifier, TTypeList& typeList)
  {
      // "If a block is qualified with xfb_offset, all its
      // members are assigned transform feedback buffer offsets. If a block is not qualified with xfb_offset, any
      // members of that block not qualified with an xfb_offset will not be assigned transform feedback buffer
      // offsets."
  
      if (! qualifier.hasXfbBuffer() || ! qualifier.hasXfbOffset())
          return;
  
      int nextOffset = qualifier.layoutXfbOffset;
      for (unsigned int member = 0; member < typeList.size(); ++member) {
          TQualifier& memberQualifier = typeList[member].type->getQualifier();
          bool contains64BitType = false;
          bool contains32BitType = false;
          bool contains16BitType = false;
          int memberSize = intermediate.computeTypeXfbSize(*typeList[member].type, contains64BitType, contains32BitType, contains16BitType);
          // see if we need to auto-assign an offset to this member
          if (! memberQualifier.hasXfbOffset()) {
              // "if applied to an aggregate containing a double or 64-bit integer, the offset must also be a multiple of 8"
              if (contains64BitType)
                  RoundToPow2(nextOffset, 8);
              else if (contains32BitType)
                  RoundToPow2(nextOffset, 4);
              // "if applied to an aggregate containing a half float or 16-bit integer, the offset must also be a multiple of 2"
              else if (contains16BitType)
                  RoundToPow2(nextOffset, 2);
              memberQualifier.layoutXfbOffset = nextOffset;
          } else
              nextOffset = memberQualifier.layoutXfbOffset;
          nextOffset += memberSize;
      }
  
      // The above gave all block members an offset, so we can take it off the block now,
      // which will avoid double counting the offset usage.
      qualifier.layoutXfbOffset = TQualifier::layoutXfbOffsetEnd;
  }
  
  // Calculate and save the offset of each block member, using the recursively
  // defined block offset rules and the user-provided offset and align.
  //
  // Also, compute and save the total size of the block. For the block's size, arrayness
  // is not taken into account, as each element is backed by a separate buffer.
  //
  void HlslParseContext::fixBlockUniformOffsets(const TQualifier& qualifier, TTypeList& typeList)
  {
      if (! qualifier.isUniformOrBuffer())
          return;
      if (qualifier.layoutPacking != ElpStd140 && qualifier.layoutPacking != ElpStd430 && qualifier.layoutPacking != ElpScalar)
          return;
  
      int offset = 0;
      int memberSize;
      for (unsigned int member = 0; member < typeList.size(); ++member) {
          TQualifier& memberQualifier = typeList[member].type->getQualifier();
          const TSourceLoc& memberLoc = typeList[member].loc;
  
          // "When align is applied to an array, it effects only the start of the array, not the array's internal stride."
  
          // modify just the children's view of matrix layout, if there is one for this member
          TLayoutMatrix subMatrixLayout = typeList[member].type->getQualifier().layoutMatrix;
          int dummyStride;
          int memberAlignment = intermediate.getMemberAlignment(*typeList[member].type, memberSize, dummyStride,
                                                                qualifier.layoutPacking,
                                                                subMatrixLayout != ElmNone
                                                                    ? subMatrixLayout == ElmRowMajor
                                                                    : qualifier.layoutMatrix == ElmRowMajor);
          if (memberQualifier.hasOffset()) {
              // "The specified offset must be a multiple
              // of the base alignment of the type of the block member it qualifies, or a compile-time error results."
              if (! IsMultipleOfPow2(memberQualifier.layoutOffset, memberAlignment))
                  error(memberLoc, "must be a multiple of the member's alignment", "offset", "");
  
              // "The offset qualifier forces the qualified member to start at or after the specified
              // integral-constant expression, which will be its byte offset from the beginning of the buffer.
              // "The actual offset of a member is computed as
              // follows: If offset was declared, start with that offset, otherwise start with the next available offset."
              offset = std::max(offset, memberQualifier.layoutOffset);
          }
  
          // "The actual alignment of a member will be the greater of the specified align alignment and the standard
          // (e.g., std140) base alignment for the member's type."
          if (memberQualifier.hasAlign())
              memberAlignment = std::max(memberAlignment, memberQualifier.layoutAlign);
  
          // "If the resulting offset is not a multiple of the actual alignment,
          // increase it to the first offset that is a multiple of
          // the actual alignment."
          RoundToPow2(offset, memberAlignment);
          typeList[member].type->getQualifier().layoutOffset = offset;
          offset += memberSize;
      }
  }
  
  // For an identifier that is already declared, add more qualification to it.
  void HlslParseContext::addQualifierToExisting(const TSourceLoc& loc, TQualifier qualifier, const TString& identifier)
  {
      TSymbol* symbol = symbolTable.find(identifier);
      if (symbol == nullptr) {
          error(loc, "identifier not previously declared", identifier.c_str(), "");
          return;
      }
      if (symbol->getAsFunction()) {
          error(loc, "cannot re-qualify a function name", identifier.c_str(), "");
          return;
      }
  
      if (qualifier.isAuxiliary() ||
          qualifier.isMemory() ||
          qualifier.isInterpolation() ||
          qualifier.hasLayout() ||
          qualifier.storage != EvqTemporary ||
          qualifier.precision != EpqNone) {
          error(loc, "cannot add storage, auxiliary, memory, interpolation, layout, or precision qualifier to an existing variable", identifier.c_str(), "");
          return;
      }
  
      // For read-only built-ins, add a new symbol for holding the modified qualifier.
      // This will bring up an entire block, if a block type has to be modified (e.g., gl_Position inside a block)
      if (symbol->isReadOnly())
          symbol = symbolTable.copyUp(symbol);
  
      if (qualifier.invariant) {
          if (intermediate.inIoAccessed(identifier))
              error(loc, "cannot change qualification after use", "invariant", "");
          symbol->getWritableType().getQualifier().invariant = true;
      } else if (qualifier.noContraction) {
          if (intermediate.inIoAccessed(identifier))
              error(loc, "cannot change qualification after use", "precise", "");
          symbol->getWritableType().getQualifier().noContraction = true;
      } else if (qualifier.specConstant) {
          symbol->getWritableType().getQualifier().makeSpecConstant();
          if (qualifier.hasSpecConstantId())
              symbol->getWritableType().getQualifier().layoutSpecConstantId = qualifier.layoutSpecConstantId;
      } else
          warn(loc, "unknown requalification", "", "");
  }
  
  void HlslParseContext::addQualifierToExisting(const TSourceLoc& loc, TQualifier qualifier, TIdentifierList& identifiers)
  {
      for (unsigned int i = 0; i < identifiers.size(); ++i)
          addQualifierToExisting(loc, qualifier, *identifiers[i]);
  }
  
  //
  // Update the intermediate for the given input geometry
  //
  bool HlslParseContext::handleInputGeometry(const TSourceLoc& loc, const TLayoutGeometry& geometry)
  {
      // these can be declared on non-entry-points, in which case they lose their meaning
      if (! parsingEntrypointParameters)
          return true;
  
      switch (geometry) {
      case ElgPoints:             // fall through
      case ElgLines:              // ...
      case ElgTriangles:          // ...
      case ElgLinesAdjacency:     // ...
      case ElgTrianglesAdjacency: // ...
          if (! intermediate.setInputPrimitive(geometry)) {
              error(loc, "input primitive geometry redefinition", TQualifier::getGeometryString(geometry), "");
              return false;
          }
          break;
  
      default:
          error(loc, "cannot apply to 'in'", TQualifier::getGeometryString(geometry), "");
          return false;
      }
  
      return true;
  }
  
  //
  // Update the intermediate for the given output geometry
  //
  bool HlslParseContext::handleOutputGeometry(const TSourceLoc& loc, const TLayoutGeometry& geometry)
  {
      // If this is not a geometry shader, ignore.  It might be a mixed shader including several stages.
      // Since that's an OK situation, return true for success.
      if (language != EShLangGeometry)
          return true;
  
      // these can be declared on non-entry-points, in which case they lose their meaning
      if (! parsingEntrypointParameters)
          return true;
  
      switch (geometry) {
      case ElgPoints:
      case ElgLineStrip:
      case ElgTriangleStrip:
          if (! intermediate.setOutputPrimitive(geometry)) {
              error(loc, "output primitive geometry redefinition", TQualifier::getGeometryString(geometry), "");
              return false;
          }
          break;
      default:
          error(loc, "cannot apply to 'out'", TQualifier::getGeometryString(geometry), "");
          return false;
      }
  
      return true;
  }
  
  //
  // Selection attributes
  //
  void HlslParseContext::handleSelectionAttributes(const TSourceLoc& loc, TIntermSelection* selection,
      const TAttributes& attributes)
  {
      if (selection == nullptr)
          return;
  
      for (auto it = attributes.begin(); it != attributes.end(); ++it) {
          switch (it->name) {
          case EatFlatten:
              selection->setFlatten();
              break;
          case EatBranch:
              selection->setDontFlatten();
              break;
          default:
              warn(loc, "attribute does not apply to a selection", "", "");
              break;
          }
      }
  }
  
  //
  // Switch attributes
  //
  void HlslParseContext::handleSwitchAttributes(const TSourceLoc& loc, TIntermSwitch* selection,
      const TAttributes& attributes)
  {
      if (selection == nullptr)
          return;
  
      for (auto it = attributes.begin(); it != attributes.end(); ++it) {
          switch (it->name) {
          case EatFlatten:
              selection->setFlatten();
              break;
          case EatBranch:
              selection->setDontFlatten();
              break;
          default:
              warn(loc, "attribute does not apply to a switch", "", "");
              break;
          }
      }
  }
  
  //
  // Loop attributes
  //
  void HlslParseContext::handleLoopAttributes(const TSourceLoc& loc, TIntermLoop* loop,
      const TAttributes& attributes)
  {
      if (loop == nullptr)
          return;
  
      for (auto it = attributes.begin(); it != attributes.end(); ++it) {
          switch (it->name) {
          case EatUnroll:
              loop->setUnroll();
              break;
          case EatLoop:
              loop->setDontUnroll();
              break;
          default:
              warn(loc, "attribute does not apply to a loop", "", "");
              break;
          }
      }
  }
  
  //
  // Updating default qualifier for the case of a declaration with just a qualifier,
  // no type, block, or identifier.
  //
  void HlslParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, const TPublicType& publicType)
  {
      if (publicType.shaderQualifiers.vertices != TQualifier::layoutNotSet) {
          assert(language == EShLangTessControl || language == EShLangGeometry);
          // const char* id = (language == EShLangTessControl) ? "vertices" : "max_vertices";
      }
      if (publicType.shaderQualifiers.invocations != TQualifier::layoutNotSet) {
          if (! intermediate.setInvocations(publicType.shaderQualifiers.invocations))
              error(loc, "cannot change previously set layout value", "invocations", "");
      }
      if (publicType.shaderQualifiers.geometry != ElgNone) {
          if (publicType.qualifier.storage == EvqVaryingIn) {
              switch (publicType.shaderQualifiers.geometry) {
              case ElgPoints:
              case ElgLines:
              case ElgLinesAdjacency:
              case ElgTriangles:
              case ElgTrianglesAdjacency:
              case ElgQuads:
              case ElgIsolines:
                  break;
              default:
                  error(loc, "cannot apply to input", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry),
                        "");
              }
          } else if (publicType.qualifier.storage == EvqVaryingOut) {
              handleOutputGeometry(loc, publicType.shaderQualifiers.geometry);
          } else
              error(loc, "cannot apply to:", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry),
                    GetStorageQualifierString(publicType.qualifier.storage));
      }
      if (publicType.shaderQualifiers.spacing != EvsNone)
          intermediate.setVertexSpacing(publicType.shaderQualifiers.spacing);
      if (publicType.shaderQualifiers.order != EvoNone)
          intermediate.setVertexOrder(publicType.shaderQualifiers.order);
      if (publicType.shaderQualifiers.pointMode)
          intermediate.setPointMode();
      for (int i = 0; i < 3; ++i) {
          if (publicType.shaderQualifiers.localSize[i] > 1) {
              int max = 0;
              switch (i) {
              case 0: max = resources.maxComputeWorkGroupSizeX; break;
              case 1: max = resources.maxComputeWorkGroupSizeY; break;
              case 2: max = resources.maxComputeWorkGroupSizeZ; break;
              default: break;
              }
              if (intermediate.getLocalSize(i) > (unsigned int)max)
                  error(loc, "too large; see gl_MaxComputeWorkGroupSize", "local_size", "");
  
              // Fix the existing constant gl_WorkGroupSize with this new information.
              TVariable* workGroupSize = getEditableVariable("gl_WorkGroupSize");
              workGroupSize->getWritableConstArray()[i].setUConst(intermediate.getLocalSize(i));
          }
          if (publicType.shaderQualifiers.localSizeSpecId[i] != TQualifier::layoutNotSet) {
              intermediate.setLocalSizeSpecId(i, publicType.shaderQualifiers.localSizeSpecId[i]);
              // Set the workgroup built-in variable as a specialization constant
              TVariable* workGroupSize = getEditableVariable("gl_WorkGroupSize");
              workGroupSize->getWritableType().getQualifier().specConstant = true;
          }
      }
      if (publicType.shaderQualifiers.earlyFragmentTests)
          intermediate.setEarlyFragmentTests();
  
      const TQualifier& qualifier = publicType.qualifier;
  
      switch (qualifier.storage) {
      case EvqUniform:
          if (qualifier.hasMatrix())
              globalUniformDefaults.layoutMatrix = qualifier.layoutMatrix;
          if (qualifier.hasPacking())
              globalUniformDefaults.layoutPacking = qualifier.layoutPacking;
          break;
      case EvqBuffer:
          if (qualifier.hasMatrix())
              globalBufferDefaults.layoutMatrix = qualifier.layoutMatrix;
          if (qualifier.hasPacking())
              globalBufferDefaults.layoutPacking = qualifier.layoutPacking;
          break;
      case EvqVaryingIn:
          break;
      case EvqVaryingOut:
          if (qualifier.hasStream())
              globalOutputDefaults.layoutStream = qualifier.layoutStream;
          if (qualifier.hasXfbBuffer())
              globalOutputDefaults.layoutXfbBuffer = qualifier.layoutXfbBuffer;
          if (globalOutputDefaults.hasXfbBuffer() && qualifier.hasXfbStride()) {
              if (! intermediate.setXfbBufferStride(globalOutputDefaults.layoutXfbBuffer, qualifier.layoutXfbStride))
                  error(loc, "all stride settings must match for xfb buffer", "xfb_stride", "%d",
                        qualifier.layoutXfbBuffer);
          }
          break;
      default:
          error(loc, "default qualifier requires 'uniform', 'buffer', 'in', or 'out' storage qualification", "", "");
          return;
      }
  }
  
  //
  // Take the sequence of statements that has been built up since the last case/default,
  // put it on the list of top-level nodes for the current (inner-most) switch statement,
  // and follow that by the case/default we are on now.  (See switch topology comment on
  // TIntermSwitch.)
  //
  void HlslParseContext::wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode)
  {
      TIntermSequence* switchSequence = switchSequenceStack.back();
  
      if (statements) {
          statements->setOperator(EOpSequence);
          switchSequence->push_back(statements);
      }
      if (branchNode) {
          // check all previous cases for the same label (or both are 'default')
          for (unsigned int s = 0; s < switchSequence->size(); ++s) {
              TIntermBranch* prevBranch = (*switchSequence)[s]->getAsBranchNode();
              if (prevBranch) {
                  TIntermTyped* prevExpression = prevBranch->getExpression();
                  TIntermTyped* newExpression = branchNode->getAsBranchNode()->getExpression();
                  if (prevExpression == nullptr && newExpression == nullptr)
                      error(branchNode->getLoc(), "duplicate label", "default", "");
                  else if (prevExpression != nullptr &&
                      newExpression != nullptr &&
                      prevExpression->getAsConstantUnion() &&
                      newExpression->getAsConstantUnion() &&
                      prevExpression->getAsConstantUnion()->getConstArray()[0].getIConst() ==
                      newExpression->getAsConstantUnion()->getConstArray()[0].getIConst())
                      error(branchNode->getLoc(), "duplicated value", "case", "");
              }
          }
          switchSequence->push_back(branchNode);
      }
  }
  
  //
  // Turn the top-level node sequence built up of wrapupSwitchSubsequence
  // into a switch node.
  //
  TIntermNode* HlslParseContext::addSwitch(const TSourceLoc& loc, TIntermTyped* expression,
                                           TIntermAggregate* lastStatements, const TAttributes& attributes)
  {
      wrapupSwitchSubsequence(lastStatements, nullptr);
  
      if (expression == nullptr ||
          (expression->getBasicType() != EbtInt && expression->getBasicType() != EbtUint) ||
          expression->getType().isArray() || expression->getType().isMatrix() || expression->getType().isVector())
          error(loc, "condition must be a scalar integer expression", "switch", "");
  
      // If there is nothing to do, drop the switch but still execute the expression
      TIntermSequence* switchSequence = switchSequenceStack.back();
      if (switchSequence->size() == 0)
          return expression;
  
      if (lastStatements == nullptr) {
          // emulate a break for error recovery
          lastStatements = intermediate.makeAggregate(intermediate.addBranch(EOpBreak, loc));
          lastStatements->setOperator(EOpSequence);
          switchSequence->push_back(lastStatements);
      }
  
      TIntermAggregate* body = new TIntermAggregate(EOpSequence);
      body->getSequence() = *switchSequenceStack.back();
      body->setLoc(loc);
  
      TIntermSwitch* switchNode = new TIntermSwitch(expression, body);
      switchNode->setLoc(loc);
      handleSwitchAttributes(loc, switchNode, attributes);
  
      return switchNode;
  }
  
  // Make a new symbol-table level that is made out of the members of a structure.
  // This should be done as an anonymous struct (name is "") so that the symbol table
  // finds the members with no explicit reference to a 'this' variable.
  void HlslParseContext::pushThisScope(const TType& thisStruct, const TVector<TFunctionDeclarator>& functionDeclarators)
  {
      // member variables
      TVariable& thisVariable = *new TVariable(NewPoolTString(""), thisStruct);
      symbolTable.pushThis(thisVariable);
  
      // member functions
      for (auto it = functionDeclarators.begin(); it != functionDeclarators.end(); ++it) {
          // member should have a prefix matching currentTypePrefix.back()
          // but, symbol lookup within the class scope will just use the
          // unprefixed name. Hence, there are two: one fully prefixed and
          // one with no prefix.
          TFunction& member = *it->function->clone();
          member.removePrefix(currentTypePrefix.back());
          symbolTable.insert(member);
      }
  }
  
  // Track levels of class/struct/namespace nesting with a prefix string using
  // the type names separated by the scoping operator. E.g., two levels
  // would look like:
  //
  //   outer::inner
  //
  // The string is empty when at normal global level.
  //
  void HlslParseContext::pushNamespace(const TString& typeName)
  {
      // make new type prefix
      TString newPrefix;
      if (currentTypePrefix.size() > 0)
          newPrefix = currentTypePrefix.back();
      newPrefix.append(typeName);
      newPrefix.append(scopeMangler);
      currentTypePrefix.push_back(newPrefix);
  }
  
  // Opposite of pushNamespace(), see above
  void HlslParseContext::popNamespace()
  {
      currentTypePrefix.pop_back();
  }
  
  // Use the class/struct nesting string to create a global name for
  // a member of a class/struct.
  void HlslParseContext::getFullNamespaceName(TString*& name) const
  {
      if (currentTypePrefix.size() == 0)
          return;
  
      TString* fullName = NewPoolTString(currentTypePrefix.back().c_str());
      fullName->append(*name);
      name = fullName;
  }
  
  // Helper function to add the namespace scope mangling syntax to a string.
  void HlslParseContext::addScopeMangler(TString& name)
  {
      name.append(scopeMangler);
  }
  
  // Return true if this has uniform-interface like decorations.
  bool HlslParseContext::hasUniform(const TQualifier& qualifier) const
  {
      return qualifier.hasUniformLayout() ||
             qualifier.layoutPushConstant;
  }
  
  // Potentially not the opposite of hasUniform(), as if some characteristic is
  // ever used for more than one thing (e.g., uniform or input), hasUniform() should
  // say it exists, but clearUniform() should leave it in place.
  void HlslParseContext::clearUniform(TQualifier& qualifier)
  {
      qualifier.clearUniformLayout();
      qualifier.layoutPushConstant = false;
  }
  
  // Return false if builtIn by itself doesn't force this qualifier to be an input qualifier.
  bool HlslParseContext::isInputBuiltIn(const TQualifier& qualifier) const
  {
      switch (qualifier.builtIn) {
      case EbvPosition:
      case EbvPointSize:
          return language != EShLangVertex && language != EShLangCompute && language != EShLangFragment;
      case EbvClipDistance:
      case EbvCullDistance:
          return language != EShLangVertex && language != EShLangCompute;
      case EbvFragCoord:
      case EbvFace:
      case EbvHelperInvocation:
      case EbvLayer:
      case EbvPointCoord:
      case EbvSampleId:
      case EbvSampleMask:
      case EbvSamplePosition:
      case EbvViewportIndex:
          return language == EShLangFragment;
      case EbvGlobalInvocationId:
      case EbvLocalInvocationIndex:
      case EbvLocalInvocationId:
      case EbvNumWorkGroups:
      case EbvWorkGroupId:
      case EbvWorkGroupSize:
          return language == EShLangCompute;
      case EbvInvocationId:
          return language == EShLangTessControl || language == EShLangTessEvaluation || language == EShLangGeometry;
      case EbvPatchVertices:
          return language == EShLangTessControl || language == EShLangTessEvaluation;
      case EbvInstanceId:
      case EbvInstanceIndex:
      case EbvVertexId:
      case EbvVertexIndex:
          return language == EShLangVertex;
      case EbvPrimitiveId:
          return language == EShLangGeometry || language == EShLangFragment || language == EShLangTessControl;
      case EbvTessLevelInner:
      case EbvTessLevelOuter:
          return language == EShLangTessEvaluation;
      case EbvTessCoord:
          return language == EShLangTessEvaluation;
      default:
          return false;
      }
  }
  
  // Return true if there are decorations to preserve for input-like storage.
  bool HlslParseContext::hasInput(const TQualifier& qualifier) const
  {
      if (qualifier.hasAnyLocation())
          return true;
  
      if (language == EShLangFragment && (qualifier.isInterpolation() || qualifier.centroid || qualifier.sample))
          return true;
  
      if (language == EShLangTessEvaluation && qualifier.patch)
          return true;
  
      if (isInputBuiltIn(qualifier))
          return true;
  
      return false;
  }
  
  // Return false if builtIn by itself doesn't force this qualifier to be an output qualifier.
  bool HlslParseContext::isOutputBuiltIn(const TQualifier& qualifier) const
  {
      switch (qualifier.builtIn) {
      case EbvPosition:
      case EbvPointSize:
      case EbvClipVertex:
      case EbvClipDistance:
      case EbvCullDistance:
          return language != EShLangFragment && language != EShLangCompute;
      case EbvFragDepth:
      case EbvFragDepthGreater:
      case EbvFragDepthLesser:
      case EbvSampleMask:
          return language == EShLangFragment;
      case EbvLayer:
      case EbvViewportIndex:
          return language == EShLangGeometry || language == EShLangVertex;
      case EbvPrimitiveId:
          return language == EShLangGeometry;
      case EbvTessLevelInner:
      case EbvTessLevelOuter:
          return language == EShLangTessControl;
      default:
          return false;
      }
  }
  
  // Return true if there are decorations to preserve for output-like storage.
  bool HlslParseContext::hasOutput(const TQualifier& qualifier) const
  {
      if (qualifier.hasAnyLocation())
          return true;
  
      if (language != EShLangFragment && language != EShLangCompute && qualifier.hasXfb())
          return true;
  
      if (language == EShLangTessControl && qualifier.patch)
          return true;
  
      if (language == EShLangGeometry && qualifier.hasStream())
          return true;
  
      if (isOutputBuiltIn(qualifier))
          return true;
  
      return false;
  }
  
  // Make the IO decorations etc. be appropriate only for an input interface.
  void HlslParseContext::correctInput(TQualifier& qualifier)
  {
      clearUniform(qualifier);
      if (language == EShLangVertex)
          qualifier.clearInterstage();
      if (language != EShLangTessEvaluation)
          qualifier.patch = false;
      if (language != EShLangFragment) {
          qualifier.clearInterpolation();
          qualifier.sample = false;
      }
  
      qualifier.clearStreamLayout();
      qualifier.clearXfbLayout();
  
      if (! isInputBuiltIn(qualifier))
          qualifier.builtIn = EbvNone;
  }
  
  // Make the IO decorations etc. be appropriate only for an output interface.
  void HlslParseContext::correctOutput(TQualifier& qualifier)
  {
      clearUniform(qualifier);
      if (language == EShLangFragment)
          qualifier.clearInterstage();
      if (language != EShLangGeometry)
          qualifier.clearStreamLayout();
      if (language == EShLangFragment)
          qualifier.clearXfbLayout();
      if (language != EShLangTessControl)
          qualifier.patch = false;
  
      switch (qualifier.builtIn) {
      case EbvFragDepth:
          intermediate.setDepthReplacing();
          intermediate.setDepth(EldAny);
          break;
      case EbvFragDepthGreater:
          intermediate.setDepthReplacing();
          intermediate.setDepth(EldGreater);
          qualifier.builtIn = EbvFragDepth;
          break;
      case EbvFragDepthLesser:
          intermediate.setDepthReplacing();
          intermediate.setDepth(EldLess);
          qualifier.builtIn = EbvFragDepth;
          break;
      default:
          break;
      }
  
      if (! isOutputBuiltIn(qualifier))
          qualifier.builtIn = EbvNone;
  }
  
  // Make the IO decorations etc. be appropriate only for uniform type interfaces.
  void HlslParseContext::correctUniform(TQualifier& qualifier)
  {
      if (qualifier.declaredBuiltIn == EbvNone)
          qualifier.declaredBuiltIn = qualifier.builtIn;
  
      qualifier.builtIn = EbvNone;
      qualifier.clearInterstage();
      qualifier.clearInterstageLayout();
  }
  
  // Clear out all IO/Uniform stuff, so this has nothing to do with being an IO interface.
  void HlslParseContext::clearUniformInputOutput(TQualifier& qualifier)
  {
      clearUniform(qualifier);
      correctUniform(qualifier);
  }
  
  
  // Set texture return type.  Returns success (not all types are valid).
  bool HlslParseContext::setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc)
  {
      // Seed the output with an invalid index.  We will set it to a valid one if we can.
      sampler.structReturnIndex = TSampler::noReturnStruct;
  
      // Arrays aren't supported.
      if (retType.isArray()) {
          error(loc, "Arrays not supported in texture template types", "", "");
          return false;
      }
  
      // If return type is a vector, remember the vector size in the sampler, and return.
      if (retType.isVector() || retType.isScalar()) {
          sampler.vectorSize = retType.getVectorSize();
          return true;
      }
  
      // If it wasn't a vector, it must be a struct meeting certain requirements.  The requirements
      // are checked below: just check for struct-ness here.
      if (!retType.isStruct()) {
          error(loc, "Invalid texture template type", "", "");
          return false;
      }
  
      // TODO: Subpass doesn't handle struct returns, due to some oddities with fn overloading.
      if (sampler.isSubpass()) {
          error(loc, "Unimplemented: structure template type in subpass input", "", "");
          return false;
      }
  
      TTypeList* members = retType.getWritableStruct();
  
      // Check for too many or not enough structure members.
      if (members->size() > 4 || members->size() == 0) {
          error(loc, "Invalid member count in texture template structure", "", "");
          return false;
      }
  
      // Error checking: We must have <= 4 total components, all of the same basic type.
      unsigned totalComponents = 0;
      for (unsigned m = 0; m < members->size(); ++m) {
          // Check for bad member types
          if (!(*members)[m].type->isScalar() && !(*members)[m].type->isVector()) {
              error(loc, "Invalid texture template struct member type", "", "");
              return false;
          }
  
          const unsigned memberVectorSize = (*members)[m].type->getVectorSize();
          totalComponents += memberVectorSize;
  
          // too many total member components
          if (totalComponents > 4) {
              error(loc, "Too many components in texture template structure type", "", "");
              return false;
          }
  
          // All members must be of a common basic type
          if ((*members)[m].type->getBasicType() != (*members)[0].type->getBasicType()) {
              error(loc, "Texture template structure members must same basic type", "", "");
              return false;
          }
      }
  
      // If the structure in the return type already exists in the table, we'll use it.  Otherwise, we'll make
      // a new entry.  This is a linear search, but it hardly ever happens, and the list cannot be very large.
      for (unsigned int idx = 0; idx < textureReturnStruct.size(); ++idx) {
          if (textureReturnStruct[idx] == members) {
              sampler.structReturnIndex = idx;
              return true;
          }
      }
  
      // It wasn't found as an existing entry.  See if we have room for a new one.
      if (textureReturnStruct.size() >= TSampler::structReturnSlots) {
          error(loc, "Texture template struct return slots exceeded", "", "");
          return false;
      }
  
      // Insert it in the vector that tracks struct return types.
      sampler.structReturnIndex = unsigned(textureReturnStruct.size());
      textureReturnStruct.push_back(members);
      
      // Success!
      return true;
  }
  
  // Return the sampler return type in retType.
  void HlslParseContext::getTextureReturnType(const TSampler& sampler, TType& retType) const
  {
      if (sampler.hasReturnStruct()) {
          assert(textureReturnStruct.size() >= sampler.structReturnIndex);
  
          // We land here if the texture return is a structure.
          TTypeList* blockStruct = textureReturnStruct[sampler.structReturnIndex];
  
          const TType resultType(blockStruct, "");
          retType.shallowCopy(resultType);
      } else {
          // We land here if the texture return is a vector or scalar.
          const TType resultType(sampler.type, EvqTemporary, sampler.getVectorSize());
          retType.shallowCopy(resultType);
      }
  }
  
  
  // Return a symbol for the tessellation linkage variable of the given TBuiltInVariable type
  TIntermSymbol* HlslParseContext::findTessLinkageSymbol(TBuiltInVariable biType) const
  {
      const auto it = builtInTessLinkageSymbols.find(biType);
      if (it == builtInTessLinkageSymbols.end())  // if it wasn't declared by the user, return nullptr
          return nullptr;
  
      return intermediate.addSymbol(*it->second->getAsVariable());
  }
  
  // Find the patch constant function (issues error, returns nullptr if not found)
  const TFunction* HlslParseContext::findPatchConstantFunction(const TSourceLoc& loc)
  {
      if (symbolTable.isFunctionNameVariable(patchConstantFunctionName)) {
          error(loc, "can't use variable in patch constant function", patchConstantFunctionName.c_str(), "");
          return nullptr;
      }
  
      const TString mangledName = patchConstantFunctionName + "(";
  
      // create list of PCF candidates
      TVector<const TFunction*> candidateList;
      bool builtIn;
      symbolTable.findFunctionNameList(mangledName, candidateList, builtIn);
      
      // We have to have one and only one, or we don't know which to pick: the patchconstantfunc does not
      // allow any disambiguation of overloads.
      if (candidateList.empty()) {
          error(loc, "patch constant function not found", patchConstantFunctionName.c_str(), "");
          return nullptr;
      }
  
      // Based on directed experiments, it appears that if there are overloaded patchconstantfunctions,
      // HLSL picks the last one in shader source order.  Since that isn't yet implemented here, error
      // out if there is more than one candidate.
      if (candidateList.size() > 1) {
          error(loc, "ambiguous patch constant function", patchConstantFunctionName.c_str(), "");
          return nullptr;
      }
  
      return candidateList[0];
  }
  
  // Finalization step: Add patch constant function invocation
  void HlslParseContext::addPatchConstantInvocation()
  {
      TSourceLoc loc;
      loc.init();
  
      // If there's no patch constant function, or we're not a HS, do nothing.
      if (patchConstantFunctionName.empty() || language != EShLangTessControl)
          return;
  
      // Look for built-in variables in a function's parameter list.
      const auto findBuiltIns = [&](const TFunction& function, std::set<tInterstageIoData>& builtIns) {
          for (int p=0; p<function.getParamCount(); ++p) {
              TStorageQualifier storage = function[p].type->getQualifier().storage;
  
              if (storage == EvqConstReadOnly) // treated identically to input
                  storage = EvqIn;
  
              if (function[p].getDeclaredBuiltIn() != EbvNone)
                  builtIns.insert(HlslParseContext::tInterstageIoData(function[p].getDeclaredBuiltIn(), storage));
              else
                  builtIns.insert(HlslParseContext::tInterstageIoData(function[p].type->getQualifier().builtIn, storage));
          }
      };
  
      // If we synthesize a built-in interface variable, we must add it to the linkage.
      const auto addToLinkage = [&](const TType& type, const TString* name, TIntermSymbol** symbolNode) {
          if (name == nullptr) {
              error(loc, "unable to locate patch function parameter name", "", "");
              return;
          } else {
              TVariable& variable = *new TVariable(name, type);
              if (! symbolTable.insert(variable)) {
                  error(loc, "unable to declare patch constant function interface variable", name->c_str(), "");
                  return;
              }
  
              globalQualifierFix(loc, variable.getWritableType().getQualifier());
  
              if (symbolNode != nullptr)
                  *symbolNode = intermediate.addSymbol(variable);
  
              trackLinkage(variable);
          }
      };
  
      const auto isOutputPatch = [](TFunction& patchConstantFunction, int param) {
          const TType& type = *patchConstantFunction[param].type;
          const TBuiltInVariable biType = patchConstantFunction[param].getDeclaredBuiltIn();
  
          return type.isSizedArray() && biType == EbvOutputPatch;
      };
      
      // We will perform these steps.  Each is in a scoped block for separation: they could
      // become separate functions to make addPatchConstantInvocation shorter.
      // 
      // 1. Union the interfaces, and create built-ins for anything present in the PCF and
      //    declared as a built-in variable that isn't present in the entry point's signature.
      //
      // 2. Synthesizes a call to the patchconstfunction using built-in variables from either main,
      //    or the ones we created.  Matching is based on built-in type.  We may use synthesized
      //    variables from (1) above.
      // 
      // 2B: Synthesize per control point invocations of wrapped entry point if the PCF requires them.
      //
      // 3. Create a return sequence: copy the return value (if any) from the PCF to a
      //    (non-sanitized) output variable.  In case this may involve multiple copies, such as for
      //    an arrayed variable, a temporary copy of the PCF output is created to avoid multiple
      //    indirections into a complex R-value coming from the call to the PCF.
      // 
      // 4. Create a barrier.
      // 
      // 5/5B. Call the PCF inside an if test for (invocation id == 0).
  
      TFunction* patchConstantFunctionPtr = const_cast<TFunction*>(findPatchConstantFunction(loc));
  
      if (patchConstantFunctionPtr == nullptr)
          return;
  
      TFunction& patchConstantFunction = *patchConstantFunctionPtr;
  
      const int pcfParamCount = patchConstantFunction.getParamCount();
      TIntermSymbol* invocationIdSym = findTessLinkageSymbol(EbvInvocationId);
      TIntermSequence& epBodySeq = entryPointFunctionBody->getAsAggregate()->getSequence();
  
      int outPatchParam = -1; // -1 means there isn't one.
  
      // ================ Step 1A: Union Interfaces ================
      // Our patch constant function.
      {
          std::set<tInterstageIoData> pcfBuiltIns;  // patch constant function built-ins
          std::set<tInterstageIoData> epfBuiltIns;  // entry point function built-ins
  
          assert(entryPointFunction);
          assert(entryPointFunctionBody);
  
          findBuiltIns(patchConstantFunction, pcfBuiltIns);
          findBuiltIns(*entryPointFunction,   epfBuiltIns);
  
          // Find the set of built-ins in the PCF that are not present in the entry point.
          std::set<tInterstageIoData> notInEntryPoint;
  
          notInEntryPoint = pcfBuiltIns;
  
          // std::set_difference not usable on unordered containers
          for (auto bi = epfBuiltIns.begin(); bi != epfBuiltIns.end(); ++bi)
              notInEntryPoint.erase(*bi);
  
          // Now we'll add those to the entry and to the linkage.
          for (int p=0; p<pcfParamCount; ++p) {
              const TBuiltInVariable biType   = patchConstantFunction[p].getDeclaredBuiltIn();
              TStorageQualifier storage = patchConstantFunction[p].type->getQualifier().storage;
  
              // Track whether there is an output patch param
              if (isOutputPatch(patchConstantFunction, p)) {
                  if (outPatchParam >= 0) {
                      // Presently we only support one per ctrl pt input.
                      error(loc, "unimplemented: multiple output patches in patch constant function", "", "");
                      return;
                  }
                  outPatchParam = p;
              }
  
              if (biType != EbvNone) {
                  TType* paramType = patchConstantFunction[p].type->clone();
  
                  if (storage == EvqConstReadOnly) // treated identically to input
                      storage = EvqIn;
  
                  // Presently, the only non-built-in we support is InputPatch, which is treated as
                  // a pseudo-built-in.
                  if (biType == EbvInputPatch) {
                      builtInTessLinkageSymbols[biType] = inputPatch;
                  } else if (biType == EbvOutputPatch) {
                      // Nothing...
                  } else {
                      // Use the original declaration type for the linkage
                      paramType->getQualifier().builtIn = biType;
  
                      if (notInEntryPoint.count(tInterstageIoData(biType, storage)) == 1)
                          addToLinkage(*paramType, patchConstantFunction[p].name, nullptr);
                  }
              }
          }
  
          // If we didn't find it because the shader made one, add our own.
          if (invocationIdSym == nullptr) {
              TType invocationIdType(EbtUint, EvqIn, 1);
              TString* invocationIdName = NewPoolTString("InvocationId");
              invocationIdType.getQualifier().builtIn = EbvInvocationId;
              addToLinkage(invocationIdType, invocationIdName, &invocationIdSym);
          }
  
          assert(invocationIdSym);
      }
  
      TIntermTyped* pcfArguments = nullptr;
      TVariable* perCtrlPtVar = nullptr;
  
      // ================ Step 1B: Argument synthesis ================
      // Create pcfArguments for synthesis of patchconstantfunction invocation
      {
          for (int p=0; p<pcfParamCount; ++p) {
              TIntermTyped* inputArg = nullptr;
  
              if (p == outPatchParam) {
                  if (perCtrlPtVar == nullptr) {
                      perCtrlPtVar = makeInternalVariable(*patchConstantFunction[outPatchParam].name,
                                                          *patchConstantFunction[outPatchParam].type);
  
                      perCtrlPtVar->getWritableType().getQualifier().makeTemporary();
                  }
                  inputArg = intermediate.addSymbol(*perCtrlPtVar, loc);
              } else {
                  // find which built-in it is
                  const TBuiltInVariable biType = patchConstantFunction[p].getDeclaredBuiltIn();
                  
                  if (biType == EbvInputPatch && inputPatch == nullptr) {
                      error(loc, "unimplemented: PCF input patch without entry point input patch parameter", "", "");
                      return;
                  }
  
                  inputArg = findTessLinkageSymbol(biType);
  
                  if (inputArg == nullptr) {
                      error(loc, "unable to find patch constant function built-in variable", "", "");
                      return;
                  }
              }
  
              if (pcfParamCount == 1)
                  pcfArguments = inputArg;
              else
                  pcfArguments = intermediate.growAggregate(pcfArguments, inputArg);
          }
      }
  
      // ================ Step 2: Synthesize call to PCF ================
      TIntermAggregate* pcfCallSequence = nullptr;
      TIntermTyped* pcfCall = nullptr;
  
      {
          // Create a function call to the patchconstantfunction
          if (pcfArguments)
              addInputArgumentConversions(patchConstantFunction, pcfArguments);
  
          // Synthetic call.
          pcfCall = intermediate.setAggregateOperator(pcfArguments, EOpFunctionCall, patchConstantFunction.getType(), loc);
          pcfCall->getAsAggregate()->setUserDefined();
          pcfCall->getAsAggregate()->setName(patchConstantFunction.getMangledName());
          intermediate.addToCallGraph(infoSink, intermediate.getEntryPointMangledName().c_str(),
                                      patchConstantFunction.getMangledName());
  
          if (pcfCall->getAsAggregate()) {
              TQualifierList& qualifierList = pcfCall->getAsAggregate()->getQualifierList();
              for (int i = 0; i < patchConstantFunction.getParamCount(); ++i) {
                  TStorageQualifier qual = patchConstantFunction[i].type->getQualifier().storage;
                  qualifierList.push_back(qual);
              }
              pcfCall = addOutputArgumentConversions(patchConstantFunction, *pcfCall->getAsOperator());
          }
      }
  
      // ================ Step 2B: Per Control Point synthesis ================
      // If there is per control point data, we must either emulate that with multiple
      // invocations of the entry point to build up an array, or (TODO:) use a yet
      // unavailable extension to look across the SIMD lanes.  This is the former
      // as a placeholder for the latter.
      if (outPatchParam >= 0) {
          // We must introduce a local temp variable of the type wanted by the PCF input.
          const int arraySize = patchConstantFunction[outPatchParam].type->getOuterArraySize();
  
          if (entryPointFunction->getType().getBasicType() == EbtVoid) {
              error(loc, "entry point must return a value for use with patch constant function", "", "");
              return;
          }
  
          // Create calls to wrapped main to fill in the array.  We will substitute fixed values
          // of invocation ID when calling the wrapped main.
  
          // This is the type of the each member of the per ctrl point array.
          const TType derefType(perCtrlPtVar->getType(), 0);
  
          for (int cpt = 0; cpt < arraySize; ++cpt) {
              // TODO: improve.  substr(1) here is to avoid the '@' that was grafted on but isn't in the symtab
              // for this function.
              const TString origName = entryPointFunction->getName().substr(1);
              TFunction callee(&origName, TType(EbtVoid));
              TIntermTyped* callingArgs = nullptr;
  
              for (int i = 0; i < entryPointFunction->getParamCount(); i++) {
                  TParameter& param = (*entryPointFunction)[i];
                  TType& paramType = *param.type;
  
                  if (paramType.getQualifier().isParamOutput()) {
                      error(loc, "unimplemented: entry point outputs in patch constant function invocation", "", "");
                      return;
                  }
  
                  if (paramType.getQualifier().isParamInput())  {
                      TIntermTyped* arg = nullptr;
                      if ((*entryPointFunction)[i].getDeclaredBuiltIn() == EbvInvocationId) {
                          // substitute invocation ID with the array element ID
                          arg = intermediate.addConstantUnion(cpt, loc);
                      } else {
                          TVariable* argVar = makeInternalVariable(*param.name, *param.type);
                          argVar->getWritableType().getQualifier().makeTemporary();
                          arg = intermediate.addSymbol(*argVar);
                      }
  
                      handleFunctionArgument(&callee, callingArgs, arg);
                  }
              }
  
              // Call and assign to per ctrl point variable
              currentCaller = intermediate.getEntryPointMangledName().c_str();
              TIntermTyped* callReturn = handleFunctionCall(loc, &callee, callingArgs);
              TIntermTyped* index = intermediate.addConstantUnion(cpt, loc);
              TIntermSymbol* perCtrlPtSym = intermediate.addSymbol(*perCtrlPtVar, loc);
              TIntermTyped* element = intermediate.addIndex(EOpIndexDirect, perCtrlPtSym, index, loc);
              element->setType(derefType);
              element->setLoc(loc);
  
              pcfCallSequence = intermediate.growAggregate(pcfCallSequence, 
                                                           handleAssign(loc, EOpAssign, element, callReturn));
          }
      }
  
      // ================ Step 3: Create return Sequence ================
      // Return sequence: copy PCF result to a temporary, then to shader output variable.
      if (pcfCall->getBasicType() != EbtVoid) {
          const TType* retType = &patchConstantFunction.getType();  // return type from the PCF
          TType outType; // output type that goes with the return type.
          outType.shallowCopy(*retType);
  
          // substitute the output type
          const auto newLists = ioTypeMap.find(retType->getStruct());
          if (newLists != ioTypeMap.end())
              outType.setStruct(newLists->second.output);
  
          // Substitute the top level type's built-in type
          if (patchConstantFunction.getDeclaredBuiltInType() != EbvNone)
              outType.getQualifier().builtIn = patchConstantFunction.getDeclaredBuiltInType();
  
          outType.getQualifier().patch = true; // make it a per-patch variable
  
          TVariable* pcfOutput = makeInternalVariable("@patchConstantOutput", outType);
          pcfOutput->getWritableType().getQualifier().storage = EvqVaryingOut;
  
          if (pcfOutput->getType().containsBuiltIn())
              split(*pcfOutput);
  
          assignToInterface(*pcfOutput);
  
          TIntermSymbol* pcfOutputSym = intermediate.addSymbol(*pcfOutput, loc);
  
          // The call to the PCF is a complex R-value: we want to store it in a temp to avoid
          // repeated calls to the PCF:
          TVariable* pcfCallResult = makeInternalVariable("@patchConstantResult", *retType);
          pcfCallResult->getWritableType().getQualifier().makeTemporary();
  
          TIntermSymbol* pcfResultVar = intermediate.addSymbol(*pcfCallResult, loc);
          TIntermNode* pcfResultAssign = handleAssign(loc, EOpAssign, pcfResultVar, pcfCall);
          TIntermNode* pcfResultToOut = handleAssign(loc, EOpAssign, pcfOutputSym,
                                                     intermediate.addSymbol(*pcfCallResult, loc));
  
          pcfCallSequence = intermediate.growAggregate(pcfCallSequence, pcfResultAssign);
          pcfCallSequence = intermediate.growAggregate(pcfCallSequence, pcfResultToOut);
      } else {
          pcfCallSequence = intermediate.growAggregate(pcfCallSequence, pcfCall);
      }
  
      // ================ Step 4: Barrier ================    
      TIntermTyped* barrier = new TIntermAggregate(EOpBarrier);
      barrier->setLoc(loc);
      barrier->setType(TType(EbtVoid));
      epBodySeq.insert(epBodySeq.end(), barrier);
  
      // ================ Step 5: Test on invocation ID ================
      TIntermTyped* zero = intermediate.addConstantUnion(0, loc, true);
      TIntermTyped* cmp =  intermediate.addBinaryNode(EOpEqual, invocationIdSym, zero, loc, TType(EbtBool));
  
  
      // ================ Step 5B: Create if statement on Invocation ID == 0 ================
      intermediate.setAggregateOperator(pcfCallSequence, EOpSequence, TType(EbtVoid), loc);
      TIntermTyped* invocationIdTest = new TIntermSelection(cmp, pcfCallSequence, nullptr);
      invocationIdTest->setLoc(loc);
  
      // add our test sequence before the return.
      epBodySeq.insert(epBodySeq.end(), invocationIdTest);
  }
  
  // Finalization step: remove unused buffer blocks from linkage (we don't know until the
  // shader is entirely compiled).
  // Preserve order of remaining symbols.
  void HlslParseContext::removeUnusedStructBufferCounters()
  {
      const auto endIt = std::remove_if(linkageSymbols.begin(), linkageSymbols.end(),
                                        [this](const TSymbol* sym) {
                                            const auto sbcIt = structBufferCounter.find(sym->getName());
                                            return sbcIt != structBufferCounter.end() && !sbcIt->second;
                                        });
  
      linkageSymbols.erase(endIt, linkageSymbols.end());
  }
  
  // Finalization step: patch texture shadow modes to match samplers they were combined with
  void HlslParseContext::fixTextureShadowModes()
  {
      for (auto symbol = linkageSymbols.begin(); symbol != linkageSymbols.end(); ++symbol) {
          TSampler& sampler = (*symbol)->getWritableType().getSampler();
  
          if (sampler.isTexture()) {
              const auto shadowMode = textureShadowVariant.find((*symbol)->getUniqueId());
              if (shadowMode != textureShadowVariant.end()) {
  
                  if (shadowMode->second->overloaded())
                      // Texture needs legalization if it's been seen with both shadow and non-shadow modes.
                      intermediate.setNeedsLegalization();
  
                  sampler.shadow = shadowMode->second->isShadowId((*symbol)->getUniqueId());
              }
          }
      }
  }
  
  // Finalization step: patch append methods to use proper stream output, which isn't known until
  // main is parsed, which could happen after the append method is parsed.
  void HlslParseContext::finalizeAppendMethods()
  {
      TSourceLoc loc;
      loc.init();
  
      // Nothing to do: bypass test for valid stream output.
      if (gsAppends.empty())
          return;
  
      if (gsStreamOutput == nullptr) {
          error(loc, "unable to find output symbol for Append()", "", "");
          return;
      }
  
      // Patch append sequences, now that we know the stream output symbol.
      for (auto append = gsAppends.begin(); append != gsAppends.end(); ++append) {
          append->node->getSequence()[0] = 
              handleAssign(append->loc, EOpAssign,
                           intermediate.addSymbol(*gsStreamOutput, append->loc),
                           append->node->getSequence()[0]->getAsTyped());
      }
  }
  
  // post-processing
  void HlslParseContext::finish()
  {
      // Error check: There was a dangling .mips operator.  These are not nested constructs in the grammar, so
      // cannot be detected there.  This is not strictly needed in a non-validating parser; it's just helpful.
      if (! mipsOperatorMipArg.empty()) {
          error(mipsOperatorMipArg.back().loc, "unterminated mips operator:", "", "");
      }
  
      removeUnusedStructBufferCounters();
      addPatchConstantInvocation();
      fixTextureShadowModes();
      finalizeAppendMethods();
  
      // Communicate out (esp. for command line) that we formed AST that will make
      // illegal AST SPIR-V and it needs transforms to legalize it.
      if (intermediate.needsLegalization() && (messages & EShMsgHlslLegalization))
          infoSink.info << "WARNING: AST will form illegal SPIR-V; need to transform to legalize";
  
      TParseContextBase::finish();
  }
  
  } // end namespace glslang
  