tor-browser

ParseContext.cpp (276901B)

---

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

#include "compiler/translator/ParseContext.h"

#include <stdarg.h>
#include <stdio.h>

#include "common/mathutil.h"
#include "common/utilities.h"
#include "compiler/preprocessor/SourceLocation.h"
#include "compiler/translator/Declarator.h"
#include "compiler/translator/StaticType.h"
#include "compiler/translator/ValidateGlobalInitializer.h"
#include "compiler/translator/ValidateSwitch.h"
#include "compiler/translator/glslang.h"
#include "compiler/translator/tree_util/IntermNode_util.h"
#include "compiler/translator/util.h"

namespace sh
{

///////////////////////////////////////////////////////////////////////
//
// Sub- vector and matrix fields
//
////////////////////////////////////////////////////////////////////////

namespace
{

const int kWebGLMaxStructNesting = 4;

bool ContainsSampler(const TStructure *structType);

bool ContainsSampler(const TType &type)
{
   if (IsSampler(type.getBasicType()))
   {
       return true;
   }
   if (type.getBasicType() == EbtStruct)
   {
       return ContainsSampler(type.getStruct());
   }

   return false;
}

bool ContainsSampler(const TStructure *structType)
{
   for (const auto &field : structType->fields())
   {
       if (ContainsSampler(*field->type()))
           return true;
   }
   return false;
}

// Get a token from an image argument to use as an error message token.
const char *GetImageArgumentToken(TIntermTyped *imageNode)
{
   ASSERT(IsImage(imageNode->getBasicType()));
   while (imageNode->getAsBinaryNode() &&
          (imageNode->getAsBinaryNode()->getOp() == EOpIndexIndirect ||
           imageNode->getAsBinaryNode()->getOp() == EOpIndexDirect))
   {
       imageNode = imageNode->getAsBinaryNode()->getLeft();
   }
   TIntermSymbol *imageSymbol = imageNode->getAsSymbolNode();
   if (imageSymbol)
   {
       return imageSymbol->getName().data();
   }
   return "image";
}

bool CanSetDefaultPrecisionOnType(const TPublicType &type)
{
   if (!SupportsPrecision(type.getBasicType()))
   {
       return false;
   }
   if (type.getBasicType() == EbtUInt)
   {
       // ESSL 3.00.4 section 4.5.4
       return false;
   }
   if (type.isAggregate())
   {
       // Not allowed to set for aggregate types
       return false;
   }
   return true;
}

// Map input primitive types to input array sizes in a geometry shader.
GLuint GetGeometryShaderInputArraySize(TLayoutPrimitiveType primitiveType)
{
   switch (primitiveType)
   {
       case EptPoints:
           return 1u;
       case EptLines:
           return 2u;
       case EptTriangles:
           return 3u;
       case EptLinesAdjacency:
           return 4u;
       case EptTrianglesAdjacency:
           return 6u;
       default:
           UNREACHABLE();
           return 0u;
   }
}

bool IsBufferOrSharedVariable(TIntermTyped *var)
{
   if (var->isInterfaceBlock() || var->getQualifier() == EvqBuffer ||
       var->getQualifier() == EvqShared)
   {
       return true;
   }
   return false;
}

TIntermTyped *FindLValueBase(TIntermTyped *node)
{
   do
   {
       const TIntermBinary *binary = node->getAsBinaryNode();
       if (binary == nullptr)
       {
           return node;
       }

       TOperator op = binary->getOp();
       if (op != EOpIndexDirect && op != EOpIndexIndirect)
       {
           return static_cast<TIntermTyped *>(nullptr);
       }

       node = binary->getLeft();
   } while (true);
}

void AddAdvancedBlendEquation(gl::BlendEquationType eq, TLayoutQualifier *qualifier)
{
   qualifier->advancedBlendEquations.set(static_cast<uint32_t>(eq));
}

constexpr bool IsValidWithPixelLocalStorage(TLayoutImageInternalFormat internalFormat)
{
   switch (internalFormat)
   {
       case EiifRGBA8:
       case EiifRGBA8I:
       case EiifRGBA8UI:
       case EiifR32F:
       case EiifR32UI:
           return true;
       default:
           return false;
   }
}
}  // namespace

// This tracks each binding point's current default offset for inheritance of subsequent
// variables using the same binding, and keeps offsets unique and non overlapping.
// See GLSL ES 3.1, section 4.4.6.
class TParseContext::AtomicCounterBindingState
{
 public:
   AtomicCounterBindingState() : mDefaultOffset(0) {}
   // Inserts a new span and returns -1 if overlapping, else returns the starting offset of
   // newly inserted span.
   int insertSpan(int start, size_t length)
   {
       gl::RangeI newSpan(start, start + static_cast<int>(length));
       for (const auto &span : mSpans)
       {
           if (newSpan.intersects(span))
           {
               return -1;
           }
       }
       mSpans.push_back(newSpan);
       mDefaultOffset = newSpan.high();
       return start;
   }
   // Inserts a new span starting from the default offset.
   int appendSpan(size_t length) { return insertSpan(mDefaultOffset, length); }
   void setDefaultOffset(int offset) { mDefaultOffset = offset; }

 private:
   int mDefaultOffset;
   std::vector<gl::RangeI> mSpans;
};

TParseContext::TParseContext(TSymbolTable &symt,
                            TExtensionBehavior &ext,
                            sh::GLenum type,
                            ShShaderSpec spec,
                            const ShCompileOptions &options,
                            bool checksPrecErrors,
                            TDiagnostics *diagnostics,
                            const ShBuiltInResources &resources,
                            ShShaderOutput outputType)
   : symbolTable(symt),
     mDeferredNonEmptyDeclarationErrorCheck(false),
     mShaderType(type),
     mShaderSpec(spec),
     mCompileOptions(options),
     mShaderVersion(100),
     mTreeRoot(nullptr),
     mLoopNestingLevel(0),
     mStructNestingLevel(0),
     mSwitchNestingLevel(0),
     mCurrentFunctionType(nullptr),
     mFunctionReturnsValue(false),
     mChecksPrecisionErrors(checksPrecErrors),
     mFragmentPrecisionHighOnESSL1(false),
     mEarlyFragmentTestsSpecified(false),
     mHasDiscard(false),
     mSampleQualifierSpecified(false),
     mDefaultUniformMatrixPacking(EmpColumnMajor),
     mDefaultUniformBlockStorage(sh::IsWebGLBasedSpec(spec) ? EbsStd140 : EbsShared),
     mDefaultBufferMatrixPacking(EmpColumnMajor),
     mDefaultBufferBlockStorage(sh::IsWebGLBasedSpec(spec) ? EbsStd140 : EbsShared),
     mDiagnostics(diagnostics),
     mDirectiveHandler(ext, *mDiagnostics, mShaderVersion, mShaderType),
     mPreprocessor(mDiagnostics, &mDirectiveHandler, angle::pp::PreprocessorSettings(spec)),
     mScanner(nullptr),
     mMinProgramTexelOffset(resources.MinProgramTexelOffset),
     mMaxProgramTexelOffset(resources.MaxProgramTexelOffset),
     mMinProgramTextureGatherOffset(resources.MinProgramTextureGatherOffset),
     mMaxProgramTextureGatherOffset(resources.MaxProgramTextureGatherOffset),
     mComputeShaderLocalSizeDeclared(false),
     mComputeShaderLocalSize(-1),
     mNumViews(-1),
     mMaxNumViews(resources.MaxViewsOVR),
     mMaxImageUnits(resources.MaxImageUnits),
     mMaxCombinedTextureImageUnits(resources.MaxCombinedTextureImageUnits),
     mMaxUniformLocations(resources.MaxUniformLocations),
     mMaxUniformBufferBindings(resources.MaxUniformBufferBindings),
     mMaxVertexAttribs(resources.MaxVertexAttribs),
     mMaxAtomicCounterBindings(resources.MaxAtomicCounterBindings),
     mMaxShaderStorageBufferBindings(resources.MaxShaderStorageBufferBindings),
     mDeclaringFunction(false),
     mGeometryShaderInputPrimitiveType(EptUndefined),
     mGeometryShaderOutputPrimitiveType(EptUndefined),
     mGeometryShaderInvocations(0),
     mGeometryShaderMaxVertices(-1),
     mMaxGeometryShaderInvocations(resources.MaxGeometryShaderInvocations),
     mMaxGeometryShaderMaxVertices(resources.MaxGeometryOutputVertices),
     mGeometryInputArraySize(0),
     mMaxPatchVertices(resources.MaxPatchVertices),
     mTessControlShaderOutputVertices(0),
     mTessEvaluationShaderInputPrimitiveType(EtetUndefined),
     mTessEvaluationShaderInputVertexSpacingType(EtetUndefined),
     mTessEvaluationShaderInputOrderingType(EtetUndefined),
     mTessEvaluationShaderInputPointType(EtetUndefined),
     mHasAnyPreciseType(false),
     mAdvancedBlendEquations(0),
     mFunctionBodyNewScope(false),
     mOutputType(outputType)
{}

TParseContext::~TParseContext() {}

bool TParseContext::anyMultiviewExtensionAvailable()
{
   return isExtensionEnabled(TExtension::OVR_multiview) ||
          isExtensionEnabled(TExtension::OVR_multiview2);
}

bool TParseContext::parseVectorFields(const TSourceLoc &line,
                                     const ImmutableString &compString,
                                     int vecSize,
                                     TVector<int> *fieldOffsets)
{
   ASSERT(fieldOffsets);
   size_t fieldCount = compString.length();
   if (fieldCount > 4u)
   {
       error(line, "illegal vector field selection", compString);
       return false;
   }
   fieldOffsets->resize(fieldCount);

   enum
   {
       exyzw,
       ergba,
       estpq
   } fieldSet[4];

   for (unsigned int i = 0u; i < fieldOffsets->size(); ++i)
   {
       switch (compString[i])
       {
           case 'x':
               (*fieldOffsets)[i] = 0;
               fieldSet[i]        = exyzw;
               break;
           case 'r':
               (*fieldOffsets)[i] = 0;
               fieldSet[i]        = ergba;
               break;
           case 's':
               (*fieldOffsets)[i] = 0;
               fieldSet[i]        = estpq;
               break;
           case 'y':
               (*fieldOffsets)[i] = 1;
               fieldSet[i]        = exyzw;
               break;
           case 'g':
               (*fieldOffsets)[i] = 1;
               fieldSet[i]        = ergba;
               break;
           case 't':
               (*fieldOffsets)[i] = 1;
               fieldSet[i]        = estpq;
               break;
           case 'z':
               (*fieldOffsets)[i] = 2;
               fieldSet[i]        = exyzw;
               break;
           case 'b':
               (*fieldOffsets)[i] = 2;
               fieldSet[i]        = ergba;
               break;
           case 'p':
               (*fieldOffsets)[i] = 2;
               fieldSet[i]        = estpq;
               break;

           case 'w':
               (*fieldOffsets)[i] = 3;
               fieldSet[i]        = exyzw;
               break;
           case 'a':
               (*fieldOffsets)[i] = 3;
               fieldSet[i]        = ergba;
               break;
           case 'q':
               (*fieldOffsets)[i] = 3;
               fieldSet[i]        = estpq;
               break;
           default:
               error(line, "illegal vector field selection", compString);
               return false;
       }
   }

   for (unsigned int i = 0u; i < fieldOffsets->size(); ++i)
   {
       if ((*fieldOffsets)[i] >= vecSize)
       {
           error(line, "vector field selection out of range", compString);
           return false;
       }

       if (i > 0)
       {
           if (fieldSet[i] != fieldSet[i - 1])
           {
               error(line, "illegal - vector component fields not from the same set", compString);
               return false;
           }
       }
   }

   return true;
}

///////////////////////////////////////////////////////////////////////
//
// Errors
//
////////////////////////////////////////////////////////////////////////

//
// Used by flex/bison to output all syntax and parsing errors.
//
void TParseContext::error(const TSourceLoc &loc, const char *reason, const char *token)
{
   mDiagnostics->error(loc, reason, token);
}

void TParseContext::error(const TSourceLoc &loc, const char *reason, const ImmutableString &token)
{
   mDiagnostics->error(loc, reason, token.data());
}

void TParseContext::warning(const TSourceLoc &loc, const char *reason, const char *token)
{
   mDiagnostics->warning(loc, reason, token);
}

void TParseContext::errorIfPLSDeclared(const TSourceLoc &loc, PLSIllegalOperations op)
{
   if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
   {
       return;
   }
   if (mPLSBindings.empty())
   {
       // No pixel local storage uniforms have been declared yet. Remember this potential error in
       // case PLS gets declared later.
       mPLSPotentialErrors.emplace_back(loc, op);
       return;
   }
   switch (op)
   {
       case PLSIllegalOperations::Discard:
           error(loc, "illegal discard when pixel local storage is declared", "discard");
           break;
       case PLSIllegalOperations::ReturnFromMain:
           error(loc, "illegal return from main when pixel local storage is declared", "return");
           break;
       case PLSIllegalOperations::AssignFragDepth:
           error(loc, "value not assignable when pixel local storage is declared", "gl_FragDepth");
           break;
       case PLSIllegalOperations::AssignSampleMask:
           error(loc, "value not assignable when pixel local storage is declared",
                 "gl_SampleMask");
           break;
   }
}

void TParseContext::outOfRangeError(bool isError,
                                   const TSourceLoc &loc,
                                   const char *reason,
                                   const char *token)
{
   if (isError)
   {
       error(loc, reason, token);
   }
   else
   {
       warning(loc, reason, token);
   }
}

void TParseContext::setTreeRoot(TIntermBlock *treeRoot)
{
   mTreeRoot = treeRoot;
   mTreeRoot->setIsTreeRoot();
}

//
// Same error message for all places assignments don't work.
//
void TParseContext::assignError(const TSourceLoc &line,
                               const char *op,
                               const TType &left,
                               const TType &right)
{
   TInfoSinkBase reasonStream;
   reasonStream << "cannot convert from '" << right << "' to '" << left << "'";
   error(line, reasonStream.c_str(), op);
}

//
// Same error message for all places unary operations don't work.
//
void TParseContext::unaryOpError(const TSourceLoc &line, const char *op, const TType &operand)
{
   TInfoSinkBase reasonStream;
   reasonStream << "wrong operand type - no operation '" << op
                << "' exists that takes an operand of type " << operand
                << " (or there is no acceptable conversion)";
   error(line, reasonStream.c_str(), op);
}

//
// Same error message for all binary operations don't work.
//
void TParseContext::binaryOpError(const TSourceLoc &line,
                                 const char *op,
                                 const TType &left,
                                 const TType &right)
{
   TInfoSinkBase reasonStream;
   reasonStream << "wrong operand types - no operation '" << op
                << "' exists that takes a left-hand operand of type '" << left
                << "' and a right operand of type '" << right
                << "' (or there is no acceptable conversion)";
   error(line, reasonStream.c_str(), op);
}

void TParseContext::checkPrecisionSpecified(const TSourceLoc &line,
                                           TPrecision precision,
                                           TBasicType type)
{
   if (!mChecksPrecisionErrors)
       return;

   if (precision != EbpUndefined && !SupportsPrecision(type))
   {
       error(line, "illegal type for precision qualifier", getBasicString(type));
   }

   if (precision == EbpUndefined)
   {
       switch (type)
       {
           case EbtFloat:
               error(line, "No precision specified for (float)", "");
               return;
           case EbtInt:
           case EbtUInt:
               UNREACHABLE();  // there's always a predeclared qualifier
               error(line, "No precision specified (int)", "");
               return;
           default:
               if (IsOpaqueType(type))
               {
                   error(line, "No precision specified", getBasicString(type));
                   return;
               }
       }
   }
}

void TParseContext::markStaticReadIfSymbol(TIntermNode *node)
{
   TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
   if (swizzleNode)
   {
       markStaticReadIfSymbol(swizzleNode->getOperand());
       return;
   }
   TIntermBinary *binaryNode = node->getAsBinaryNode();
   if (binaryNode)
   {
       switch (binaryNode->getOp())
       {
           case EOpIndexDirect:
           case EOpIndexIndirect:
           case EOpIndexDirectStruct:
           case EOpIndexDirectInterfaceBlock:
               markStaticReadIfSymbol(binaryNode->getLeft());
               return;
           default:
               return;
       }
   }
   TIntermSymbol *symbolNode = node->getAsSymbolNode();
   if (symbolNode)
   {
       symbolTable.markStaticRead(symbolNode->variable());
   }
}

// 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.
bool TParseContext::checkCanBeLValue(const TSourceLoc &line, const char *op, TIntermTyped *node)
{
   TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
   if (swizzleNode)
   {
       bool ok = checkCanBeLValue(line, op, swizzleNode->getOperand());
       if (ok && swizzleNode->hasDuplicateOffsets())
       {
           error(line, " l-value of swizzle cannot have duplicate components", op);
           return false;
       }
       return ok;
   }

   TIntermBinary *binaryNode = node->getAsBinaryNode();
   if (binaryNode)
   {
       switch (binaryNode->getOp())
       {
           case EOpIndexDirect:
           case EOpIndexIndirect:
           case EOpIndexDirectStruct:
           case EOpIndexDirectInterfaceBlock:
               if (node->getMemoryQualifier().readonly)
               {
                   error(line, "can't modify a readonly variable", op);
                   return false;
               }
               return checkCanBeLValue(line, op, binaryNode->getLeft());
           default:
               break;
       }
       error(line, " l-value required", op);
       return false;
   }

   std::string message;
   switch (node->getQualifier())
   {
       case EvqConst:
           message = "can't modify a const";
           break;
       case EvqParamConst:
           message = "can't modify a const";
           break;
       case EvqAttribute:
           message = "can't modify an attribute";
           break;
       case EvqFragmentIn:
       case EvqVertexIn:
       case EvqGeometryIn:
       case EvqTessControlIn:
       case EvqTessEvaluationIn:
       case EvqFlatIn:
       case EvqNoPerspectiveIn:
       case EvqSmoothIn:
       case EvqCentroidIn:
       case EvqSampleIn:
           message = "can't modify an input";
           break;
       case EvqUniform:
           message = "can't modify a uniform";
           break;
       case EvqVaryingIn:
           message = "can't modify a varying";
           break;
       case EvqFragCoord:
           message = "can't modify gl_FragCoord";
           break;
       case EvqFrontFacing:
           message = "can't modify gl_FrontFacing";
           break;
       case EvqHelperInvocation:
           message = "can't modify gl_HelperInvocation";
           break;
       case EvqPointCoord:
           message = "can't modify gl_PointCoord";
           break;
       case EvqNumWorkGroups:
           message = "can't modify gl_NumWorkGroups";
           break;
       case EvqWorkGroupSize:
           message = "can't modify gl_WorkGroupSize";
           break;
       case EvqWorkGroupID:
           message = "can't modify gl_WorkGroupID";
           break;
       case EvqLocalInvocationID:
           message = "can't modify gl_LocalInvocationID";
           break;
       case EvqGlobalInvocationID:
           message = "can't modify gl_GlobalInvocationID";
           break;
       case EvqLocalInvocationIndex:
           message = "can't modify gl_LocalInvocationIndex";
           break;
       case EvqViewIDOVR:
           message = "can't modify gl_ViewID_OVR";
           break;
       case EvqComputeIn:
           message = "can't modify work group size variable";
           break;
       case EvqPerVertexIn:
           message = "can't modify any member in gl_in";
           break;
       case EvqPrimitiveIDIn:
           message = "can't modify gl_PrimitiveIDIn";
           break;
       case EvqInvocationID:
           message = "can't modify gl_InvocationID";
           break;
       case EvqPrimitiveID:
           if (mShaderType == GL_FRAGMENT_SHADER)
           {
               message = "can't modify gl_PrimitiveID in a fragment shader";
           }
           break;
       case EvqLayerIn:
           message = "can't modify gl_Layer in a fragment shader";
           break;
       case EvqSampleID:
           message = "can't modify gl_SampleID";
           break;
       case EvqSampleMaskIn:
           message = "can't modify gl_SampleMaskIn";
           break;
       case EvqSamplePosition:
           message = "can't modify gl_SamplePosition";
           break;
       case EvqClipDistance:
           if (mShaderType == GL_FRAGMENT_SHADER)
           {
               message = "can't modify gl_ClipDistance in a fragment shader";
           }
           break;
       case EvqCullDistance:
           if (mShaderType == GL_FRAGMENT_SHADER)
           {
               message = "can't modify gl_CullDistance in a fragment shader";
           }
           break;
       case EvqFragDepth:
           errorIfPLSDeclared(line, PLSIllegalOperations::AssignFragDepth);
           break;
       case EvqSampleMask:
           errorIfPLSDeclared(line, PLSIllegalOperations::AssignSampleMask);
           break;
       default:
           //
           // Type that can't be written to?
           //
           if (node->getBasicType() == EbtVoid)
           {
               message = "can't modify void";
           }
           if (IsOpaqueType(node->getBasicType()))
           {
               message = "can't modify a variable with type ";
               message += getBasicString(node->getBasicType());
           }
           else if (node->getMemoryQualifier().readonly)
           {
               message = "can't modify a readonly variable";
           }
   }

   ASSERT(binaryNode == nullptr && swizzleNode == nullptr);
   TIntermSymbol *symNode = node->getAsSymbolNode();
   if (message.empty() && symNode != nullptr)
   {
       symbolTable.markStaticWrite(symNode->variable());
       return true;
   }

   std::stringstream reasonStream = sh::InitializeStream<std::stringstream>();
   reasonStream << "l-value required";
   if (!message.empty())
   {
       if (symNode)
       {
           // Symbol inside an expression can't be nameless.
           ASSERT(symNode->variable().symbolType() != SymbolType::Empty);
           const ImmutableString &symbol = symNode->getName();
           reasonStream << " (" << message << " \"" << symbol << "\")";
       }
       else
       {
           reasonStream << " (" << message << ")";
       }
   }
   std::string reason = reasonStream.str();
   error(line, reason.c_str(), op);

   return false;
}

// Both test, and if necessary spit out an error, to see if the node is really
// a constant.
void TParseContext::checkIsConst(TIntermTyped *node)
{
   if (node->getQualifier() != EvqConst)
   {
       error(node->getLine(), "constant expression required", "");
   }
}

// Both test, and if necessary spit out an error, to see if the node is really
// an integer.
void TParseContext::checkIsScalarInteger(TIntermTyped *node, const char *token)
{
   if (!node->isScalarInt())
   {
       error(node->getLine(), "integer expression required", token);
   }
}

// Both test, and if necessary spit out an error, to see if we are currently
// globally scoped.
bool TParseContext::checkIsAtGlobalLevel(const TSourceLoc &line, const char *token)
{
   if (!symbolTable.atGlobalLevel())
   {
       error(line, "only allowed at global scope", token);
       return false;
   }
   return true;
}

// ESSL 3.00.5 sections 3.8 and 3.9.
// If it starts "gl_" or contains two consecutive underscores, it's reserved.
// Also checks for "webgl_" and "_webgl_" reserved identifiers if parsing a webgl shader.
bool TParseContext::checkIsNotReserved(const TSourceLoc &line, const ImmutableString &identifier)
{
   static const char *reservedErrMsg = "reserved built-in name";
   if (gl::IsBuiltInName(identifier.data()))
   {
       error(line, reservedErrMsg, "gl_");
       return false;
   }
   if (sh::IsWebGLBasedSpec(mShaderSpec))
   {
       if (identifier.beginsWith("webgl_"))
       {
           error(line, reservedErrMsg, "webgl_");
           return false;
       }
       if (identifier.beginsWith("_webgl_"))
       {
           error(line, reservedErrMsg, "_webgl_");
           return false;
       }
   }
   if (identifier.contains("__"))
   {
       if (sh::IsWebGLBasedSpec(mShaderSpec))
       {
           error(line,
                 "identifiers containing two consecutive underscores (__) are reserved as "
                 "possible future keywords",
                 identifier);
           return false;
       }
       else
       {
           // Using double underscores is allowed, but may result in unintended behaviors, so a
           // warning is issued.
           // OpenGL ES Shader Language 3.2 specification:
           // > 3.7. Keywords
           // > ...
           // > In addition, all identifiers containing two consecutive underscores (__) are
           // > reserved for use by underlying software layers. Defining such a name in a shader
           // > does not itself result in an error, but may result in unintended behaviors that
           // > stem from having multiple definitions of the same name.
           warning(line,
                   "all identifiers containing two consecutive underscores (__) are reserved - "
                   "unintented behaviors are possible",
                   identifier.data());
       }
   }
   return true;
}

// Make sure the argument types are correct for constructing a specific type.
bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
                                             const TIntermSequence &arguments,
                                             const TType &type)
{
   if (arguments.empty())
   {
       error(line, "constructor does not have any arguments", "constructor");
       return false;
   }

   for (TIntermNode *arg : arguments)
   {
       markStaticReadIfSymbol(arg);
       const TIntermTyped *argTyped = arg->getAsTyped();
       ASSERT(argTyped != nullptr);
       if (type.getBasicType() != EbtStruct && IsOpaqueType(argTyped->getBasicType()))
       {
           std::string reason("cannot convert a variable with type ");
           reason += getBasicString(argTyped->getBasicType());
           error(line, reason.c_str(), "constructor");
           return false;
       }
       else if (argTyped->getMemoryQualifier().writeonly)
       {
           error(line, "cannot convert a variable with writeonly", "constructor");
           return false;
       }
       if (argTyped->getBasicType() == EbtVoid)
       {
           error(line, "cannot convert a void", "constructor");
           return false;
       }
   }

   if (type.isArray())
   {
       // The size of an unsized constructor should already have been determined.
       ASSERT(!type.isUnsizedArray());
       if (static_cast<size_t>(type.getOutermostArraySize()) != arguments.size())
       {
           error(line, "array constructor needs one argument per array element", "constructor");
           return false;
       }
       // GLSL ES 3.00 section 5.4.4: Each argument must be the same type as the element type of
       // the array.
       for (TIntermNode *const &argNode : arguments)
       {
           const TType &argType = argNode->getAsTyped()->getType();
           if (mShaderVersion < 310 && argType.isArray())
           {
               error(line, "constructing from a non-dereferenced array", "constructor");
               return false;
           }
           if (!argType.isElementTypeOf(type))
           {
               error(line, "Array constructor argument has an incorrect type", "constructor");
               return false;
           }
       }
   }
   else if (type.getBasicType() == EbtStruct)
   {
       const TFieldList &fields = type.getStruct()->fields();
       if (fields.size() != arguments.size())
       {
           error(line,
                 "Number of constructor parameters does not match the number of structure fields",
                 "constructor");
           return false;
       }

       for (size_t i = 0; i < fields.size(); i++)
       {
           if (i >= arguments.size() ||
               arguments[i]->getAsTyped()->getType() != *fields[i]->type())
           {
               error(line, "Structure constructor arguments do not match structure fields",
                     "constructor");
               return false;
           }
       }
   }
   else
   {
       // We're constructing a scalar, vector, or matrix.

       // Note: It's okay to have too many components available, but not okay to have unused
       // arguments. 'full' will go to true when enough args have been seen. If we loop again,
       // there is an extra argument, so 'overFull' will become true.

       size_t size    = 0;
       bool full      = false;
       bool overFull  = false;
       bool matrixArg = false;
       for (TIntermNode *arg : arguments)
       {
           const TIntermTyped *argTyped = arg->getAsTyped();
           ASSERT(argTyped != nullptr);

           if (argTyped->getBasicType() == EbtStruct)
           {
               error(line, "a struct cannot be used as a constructor argument for this type",
                     "constructor");
               return false;
           }
           if (argTyped->getType().isArray())
           {
               error(line, "constructing from a non-dereferenced array", "constructor");
               return false;
           }
           if (argTyped->getType().isMatrix())
           {
               matrixArg = true;
           }

           size += argTyped->getType().getObjectSize();
           if (full)
           {
               overFull = true;
           }
           if (size >= type.getObjectSize())
           {
               full = true;
           }
       }

       if (type.isMatrix() && matrixArg)
       {
           if (arguments.size() != 1)
           {
               error(line, "constructing matrix from matrix can only take one argument",
                     "constructor");
               return false;
           }
       }
       else
       {
           if (size != 1 && size < type.getObjectSize())
           {
               error(line, "not enough data provided for construction", "constructor");
               return false;
           }
           if (overFull)
           {
               error(line, "too many arguments", "constructor");
               return false;
           }
       }
   }

   return true;
}

// This function 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 TParseContext::checkIsNonVoid(const TSourceLoc &line,
                                  const ImmutableString &identifier,
                                  const TBasicType &type)
{
   if (type == EbtVoid)
   {
       error(line, "illegal use of type 'void'", identifier);
       return false;
   }

   return true;
}

// This function checks to see if the node (for the expression) contains a scalar boolean expression
// or not.
bool TParseContext::checkIsScalarBool(const TSourceLoc &line, const TIntermTyped *type)
{
   if (type->getBasicType() != EbtBool || !type->isScalar())
   {
       error(line, "boolean expression expected", "");
       return false;
   }
   return true;
}

// This function checks to see if the node (for the expression) contains a scalar boolean expression
// or not.
void TParseContext::checkIsScalarBool(const TSourceLoc &line, const TPublicType &pType)
{
   if (pType.getBasicType() != EbtBool || pType.isAggregate())
   {
       error(line, "boolean expression expected", "");
   }
}

bool TParseContext::checkIsNotOpaqueType(const TSourceLoc &line,
                                        const TTypeSpecifierNonArray &pType,
                                        const char *reason)
{
   if (pType.type == EbtStruct)
   {
       if (ContainsSampler(pType.userDef))
       {
           std::stringstream reasonStream = sh::InitializeStream<std::stringstream>();
           reasonStream << reason << " (structure contains a sampler)";
           std::string reasonStr = reasonStream.str();
           error(line, reasonStr.c_str(), getBasicString(pType.type));
           return false;
       }
       // only samplers need to be checked from structs, since other opaque types can't be struct
       // members.
       return true;
   }
   else if (IsOpaqueType(pType.type))
   {
       error(line, reason, getBasicString(pType.type));
       return false;
   }

   return true;
}

void TParseContext::checkDeclaratorLocationIsNotSpecified(const TSourceLoc &line,
                                                         const TPublicType &pType)
{
   if (pType.layoutQualifier.location != -1)
   {
       error(line, "location must only be specified for a single input or output variable",
             "location");
   }
}

void TParseContext::checkLocationIsNotSpecified(const TSourceLoc &location,
                                               const TLayoutQualifier &layoutQualifier)
{
   if (layoutQualifier.location != -1)
   {
       const char *errorMsg = "invalid layout qualifier: only valid on program inputs and outputs";
       if (mShaderVersion >= 310)
       {
           errorMsg =
               "invalid layout qualifier: only valid on shader inputs, outputs, and uniforms";
       }
       error(location, errorMsg, "location");
   }
}

void TParseContext::checkStd430IsForShaderStorageBlock(const TSourceLoc &location,
                                                      const TLayoutBlockStorage &blockStorage,
                                                      const TQualifier &qualifier)
{
   if (blockStorage == EbsStd430 && qualifier != EvqBuffer)
   {
       error(location, "The std430 layout is supported only for shader storage blocks.", "std430");
   }
}

void TParseContext::checkOutParameterIsNotOpaqueType(const TSourceLoc &line,
                                                    TQualifier qualifier,
                                                    const TType &type)
{
   ASSERT(qualifier == EvqParamOut || qualifier == EvqParamInOut);
   if (IsOpaqueType(type.getBasicType()))
   {
       error(line, "opaque types cannot be output parameters", type.getBasicString());
   }
}

// Do size checking for an array type's size.
unsigned int TParseContext::checkIsValidArraySize(const TSourceLoc &line, TIntermTyped *expr)
{
   TIntermConstantUnion *constant = expr->getAsConstantUnion();

   // ANGLE should be able to fold any EvqConst expressions resulting in an integer - but to be
   // safe against corner cases we still check for constant folding. Some interpretations of the
   // spec have allowed constant expressions with side effects - like array length() method on a
   // non-constant array.
   if (expr->getQualifier() != EvqConst || constant == nullptr || !constant->isScalarInt())
   {
       error(line, "array size must be a constant integer expression", "");
       return 1u;
   }

   unsigned int size = 0u;

   if (constant->getBasicType() == EbtUInt)
   {
       size = constant->getUConst(0);
   }
   else
   {
       int signedSize = constant->getIConst(0);

       if (signedSize < 0)
       {
           error(line, "array size must be non-negative", "");
           return 1u;
       }

       size = static_cast<unsigned int>(signedSize);
   }

   if (size == 0u)
   {
       error(line, "array size must be greater than zero", "");
       return 1u;
   }

   if (IsOutputHLSL(getOutputType()))
   {
       // The size of arrays is restricted here to prevent issues further down the
       // compiler/translator/driver stack. Shader Model 5 generation hardware is limited to
       // 4096 registers so this should be reasonable even for aggressively optimizable code.
       const unsigned int sizeLimit = 65536;

       if (size > sizeLimit)
       {
           error(line, "array size too large", "");
           return 1u;
       }
   }

   return size;
}

// See if this qualifier can be an array.
bool TParseContext::checkIsValidQualifierForArray(const TSourceLoc &line,
                                                 const TPublicType &elementQualifier)
{
   if ((elementQualifier.qualifier == EvqAttribute) ||
       (elementQualifier.qualifier == EvqVertexIn) ||
       (elementQualifier.qualifier == EvqConst && mShaderVersion < 300))
   {
       error(line, "cannot declare arrays of this qualifier",
             TType(elementQualifier).getQualifierString());
       return false;
   }

   return true;
}

// See if this element type can be formed into an array.
bool TParseContext::checkArrayElementIsNotArray(const TSourceLoc &line,
                                               const TPublicType &elementType)
{
   if (mShaderVersion < 310 && elementType.isArray())
   {
       TInfoSinkBase typeString;
       typeString << TType(elementType);
       error(line, "cannot declare arrays of arrays", typeString.c_str());
       return false;
   }
   return true;
}

// Check for array-of-arrays being used as non-allowed shader inputs/outputs.
bool TParseContext::checkArrayOfArraysInOut(const TSourceLoc &line,
                                           const TPublicType &elementType,
                                           const TType &arrayType)
{
   if (arrayType.isArrayOfArrays())
   {
       if (elementType.qualifier == EvqVertexOut)
       {
           error(line, "vertex shader output cannot be an array of arrays",
                 TType(elementType).getQualifierString());
           return false;
       }
       if (elementType.qualifier == EvqFragmentIn)
       {
           error(line, "fragment shader input cannot be an array of arrays",
                 TType(elementType).getQualifierString());
           return false;
       }
       if (elementType.qualifier == EvqFragmentOut || elementType.qualifier == EvqFragmentInOut)
       {
           error(line, "fragment shader output cannot be an array of arrays",
                 TType(elementType).getQualifierString());
           return false;
       }
   }
   return true;
}

// Check if this qualified element type can be formed into an array. This is only called when array
// brackets are associated with an identifier in a declaration, like this:
//   float a[2];
// Similar checks are done in addFullySpecifiedType for array declarations where the array brackets
// are associated with the type, like this:
//   float[2] a;
bool TParseContext::checkIsValidTypeAndQualifierForArray(const TSourceLoc &indexLocation,
                                                        const TPublicType &elementType)
{
   if (!checkArrayElementIsNotArray(indexLocation, elementType))
   {
       return false;
   }
   // In ESSL1.00 shaders, structs cannot be varying (section 4.3.5). This is checked elsewhere.
   // In ESSL3.00 shaders, struct inputs/outputs are allowed but not arrays of structs (section
   // 4.3.4).
   // Geometry shader requires each user-defined input be declared as arrays or inside input
   // blocks declared as arrays (GL_EXT_geometry_shader section 11.1gs.4.3). For the purposes of
   // interface matching, such variables and blocks are treated as though they were not declared
   // as arrays (GL_EXT_geometry_shader section 7.4.1).
   if (mShaderVersion >= 300 && elementType.getBasicType() == EbtStruct &&
       sh::IsVarying(elementType.qualifier) &&
       !IsGeometryShaderInput(mShaderType, elementType.qualifier) &&
       !IsTessellationControlShaderInput(mShaderType, elementType.qualifier) &&
       !IsTessellationEvaluationShaderInput(mShaderType, elementType.qualifier) &&
       !IsTessellationControlShaderOutput(mShaderType, elementType.qualifier))
   {
       TInfoSinkBase typeString;
       typeString << TType(elementType);
       error(indexLocation, "cannot declare arrays of structs of this qualifier",
             typeString.c_str());
       return false;
   }
   return checkIsValidQualifierForArray(indexLocation, elementType);
}

// Enforce non-initializer type/qualifier rules.
void TParseContext::checkCanBeDeclaredWithoutInitializer(const TSourceLoc &line,
                                                        const ImmutableString &identifier,
                                                        TType *type)
{
   ASSERT(type != nullptr);
   if (type->getQualifier() == EvqConst)
   {
       // Make the qualifier make sense.
       type->setQualifier(EvqTemporary);

       // Generate informative error messages for ESSL1.
       // In ESSL3 arrays and structures containing arrays can be constant.
       if (mShaderVersion < 300 && type->isStructureContainingArrays())
       {
           error(line,
                 "structures containing arrays may not be declared constant since they cannot be "
                 "initialized",
                 identifier);
       }
       else
       {
           error(line, "variables with qualifier 'const' must be initialized", identifier);
       }
   }

   // Implicitly declared arrays are only allowed with tessellation or geometry shader inputs
   if (type->isArray() &&
       ((mShaderType != GL_TESS_CONTROL_SHADER && mShaderType != GL_TESS_EVALUATION_SHADER &&
         mShaderType != GL_GEOMETRY_SHADER) ||
        (mShaderType == GL_GEOMETRY_SHADER && type->getQualifier() == EvqGeometryOut)))
   {
       const TSpan<const unsigned int> &arraySizes = type->getArraySizes();
       for (unsigned int size : arraySizes)
       {
           if (size == 0)
           {
               error(line,
                     "implicitly sized arrays only allowed for tessellation shaders "
                     "or geometry shader inputs",
                     identifier);
           }
       }
   }
}

// Do some simple checks that are shared between all variable declarations,
// and update the symbol table.
//
// Returns true if declaring the variable succeeded.
//
bool TParseContext::declareVariable(const TSourceLoc &line,
                                   const ImmutableString &identifier,
                                   const TType *type,
                                   TVariable **variable)
{
   ASSERT((*variable) == nullptr);

   SymbolType symbolType = SymbolType::UserDefined;
   switch (type->getQualifier())
   {
       case EvqClipDistance:
       case EvqCullDistance:
       case EvqLastFragData:
           symbolType = SymbolType::BuiltIn;
           break;
       default:
           break;
   }

   (*variable) = new TVariable(&symbolTable, identifier, type, symbolType);

   ASSERT(type->getLayoutQualifier().index == -1 ||
          (isExtensionEnabled(TExtension::EXT_blend_func_extended) &&
           mShaderType == GL_FRAGMENT_SHADER && mShaderVersion >= 300));
   if (type->getQualifier() == EvqFragmentOut)
   {
       if (type->getLayoutQualifier().index != -1 && type->getLayoutQualifier().location == -1)
       {
           error(line,
                 "If index layout qualifier is specified for a fragment output, location must "
                 "also be specified.",
                 "index");
           return false;
       }
   }
   else
   {
       checkIndexIsNotSpecified(line, type->getLayoutQualifier().index);
   }

   if (!((identifier.beginsWith("gl_LastFragData") || type->getQualifier() == EvqFragmentInOut) &&
         (isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch) ||
          isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch_non_coherent))))
   {
       checkNoncoherentIsNotSpecified(line, type->getLayoutQualifier().noncoherent);
   }
   else if (isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch_non_coherent) &&
            !isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch))
   {
       checkNoncoherentIsSpecified(line, type->getLayoutQualifier().noncoherent);
   }

   checkBindingIsValid(line, *type);

   bool needsReservedCheck = true;

   // gl_LastFragData may be redeclared with a new precision qualifier
   if (type->isArray() && identifier.beginsWith("gl_LastFragData"))
   {
       const TVariable *maxDrawBuffers = static_cast<const TVariable *>(
           symbolTable.findBuiltIn(ImmutableString("gl_MaxDrawBuffers"), mShaderVersion));
       if (type->isArrayOfArrays())
       {
           error(line, "redeclaration of gl_LastFragData as an array of arrays", identifier);
           return false;
       }
       else if (static_cast<int>(type->getOutermostArraySize()) ==
                maxDrawBuffers->getConstPointer()->getIConst())
       {
           if (const TSymbol *builtInSymbol = symbolTable.findBuiltIn(identifier, mShaderVersion))
           {
               needsReservedCheck = !checkCanUseOneOfExtensions(line, builtInSymbol->extensions());
           }
       }
       else
       {
           error(line, "redeclaration of gl_LastFragData with size != gl_MaxDrawBuffers",
                 identifier);
           return false;
       }
   }
   else if (type->isArray() && identifier == "gl_ClipDistance")
   {
       // gl_ClipDistance can be redeclared with smaller size than gl_MaxClipDistances
       const TVariable *maxClipDistances = static_cast<const TVariable *>(
           symbolTable.findBuiltIn(ImmutableString("gl_MaxClipDistances"), mShaderVersion));
       if (!maxClipDistances)
       {
           // Unsupported extension
           needsReservedCheck = true;
       }
       else if (type->isArrayOfArrays())
       {
           error(line, "redeclaration of gl_ClipDistance as an array of arrays", identifier);
           return false;
       }
       else if (static_cast<int>(type->getOutermostArraySize()) <=
                maxClipDistances->getConstPointer()->getIConst())
       {
           const TSymbol *builtInSymbol = symbolTable.findBuiltIn(identifier, mShaderVersion);
           if (builtInSymbol)
           {
               needsReservedCheck = !checkCanUseOneOfExtensions(line, builtInSymbol->extensions());
           }
       }
       else
       {
           error(line, "redeclaration of gl_ClipDistance with size > gl_MaxClipDistances",
                 identifier);
           return false;
       }
   }
   else if (type->isArray() && identifier == "gl_CullDistance")
   {
       // gl_CullDistance can be redeclared with smaller size than gl_MaxCullDistances
       const TVariable *maxCullDistances = static_cast<const TVariable *>(
           symbolTable.findBuiltIn(ImmutableString("gl_MaxCullDistances"), mShaderVersion));
       if (!maxCullDistances)
       {
           // Unsupported extension
           needsReservedCheck = true;
       }
       else if (type->isArrayOfArrays())
       {
           error(line, "redeclaration of gl_CullDistance as an array of arrays", identifier);
           return false;
       }
       else if (static_cast<int>(type->getOutermostArraySize()) <=
                maxCullDistances->getConstPointer()->getIConst())
       {
           if (const TSymbol *builtInSymbol = symbolTable.findBuiltIn(identifier, mShaderVersion))
           {
               needsReservedCheck = !checkCanUseOneOfExtensions(line, builtInSymbol->extensions());
           }
       }
       else
       {
           error(line, "redeclaration of gl_CullDistance with size > gl_MaxCullDistances",
                 identifier);
           return false;
       }
   }

   if (needsReservedCheck && !checkIsNotReserved(line, identifier))
       return false;

   if (!symbolTable.declare(*variable))
   {
       error(line, "redefinition", identifier);
       return false;
   }

   if (!checkIsNonVoid(line, identifier, type->getBasicType()))
       return false;

   return true;
}

void TParseContext::checkIsParameterQualifierValid(
   const TSourceLoc &line,
   const TTypeQualifierBuilder &typeQualifierBuilder,
   TType *type)
{
   // The only parameter qualifiers a parameter can have are in, out, inout or const.
   TTypeQualifier typeQualifier =
       typeQualifierBuilder.getParameterTypeQualifier(type->getBasicType(), mDiagnostics);

   if (typeQualifier.qualifier == EvqParamOut || typeQualifier.qualifier == EvqParamInOut)
   {
       checkOutParameterIsNotOpaqueType(line, typeQualifier.qualifier, *type);
   }

   if (!IsImage(type->getBasicType()))
   {
       checkMemoryQualifierIsNotSpecified(typeQualifier.memoryQualifier, line);
   }
   else
   {
       type->setMemoryQualifier(typeQualifier.memoryQualifier);
   }

   type->setQualifier(typeQualifier.qualifier);

   if (typeQualifier.precision != EbpUndefined)
   {
       type->setPrecision(typeQualifier.precision);
   }

   if (typeQualifier.precise)
   {
       type->setPrecise(true);
   }
}

template <size_t size>
bool TParseContext::checkCanUseOneOfExtensions(const TSourceLoc &line,
                                              const std::array<TExtension, size> &extensions)
{
   ASSERT(!extensions.empty());
   const TExtensionBehavior &extBehavior = extensionBehavior();

   bool canUseWithWarning    = false;
   bool canUseWithoutWarning = false;

   const char *errorMsgString   = "";
   TExtension errorMsgExtension = TExtension::UNDEFINED;

   for (TExtension extension : extensions)
   {
       auto extIter = extBehavior.find(extension);
       if (canUseWithWarning)
       {
           // We already have an extension that we can use, but with a warning.
           // See if we can use the alternative extension without a warning.
           if (extIter == extBehavior.end())
           {
               continue;
           }
           if (extIter->second == EBhEnable || extIter->second == EBhRequire)
           {
               canUseWithoutWarning = true;
               break;
           }
           continue;
       }
       if (extension == TExtension::UNDEFINED)
       {
           continue;
       }
       else if (extIter == extBehavior.end())
       {
           errorMsgString    = "extension is not supported";
           errorMsgExtension = extension;
       }
       else if (extIter->second == EBhUndefined || extIter->second == EBhDisable)
       {
           errorMsgString    = "extension is disabled";
           errorMsgExtension = extension;
       }
       else if (extIter->second == EBhWarn)
       {
           errorMsgExtension = extension;
           canUseWithWarning = true;
       }
       else
       {
           ASSERT(extIter->second == EBhEnable || extIter->second == EBhRequire);
           canUseWithoutWarning = true;
           break;
       }
   }

   if (canUseWithoutWarning)
   {
       return true;
   }
   if (canUseWithWarning)
   {
       warning(line, "extension is being used", GetExtensionNameString(errorMsgExtension));
       return true;
   }
   error(line, errorMsgString, GetExtensionNameString(errorMsgExtension));
   return false;
}

template bool TParseContext::checkCanUseOneOfExtensions(
   const TSourceLoc &line,
   const std::array<TExtension, 1> &extensions);
template bool TParseContext::checkCanUseOneOfExtensions(
   const TSourceLoc &line,
   const std::array<TExtension, 2> &extensions);
template bool TParseContext::checkCanUseOneOfExtensions(
   const TSourceLoc &line,
   const std::array<TExtension, 3> &extensions);

bool TParseContext::checkCanUseExtension(const TSourceLoc &line, TExtension extension)
{
   ASSERT(extension != TExtension::UNDEFINED);
   return checkCanUseOneOfExtensions(line, std::array<TExtension, 1u>{{extension}});
}

// ESSL 3.00.6 section 4.8 Empty Declarations: "The combinations of qualifiers that cause
// compile-time or link-time errors are the same whether or not the declaration is empty".
// This function implements all the checks that are done on qualifiers regardless of if the
// declaration is empty.
void TParseContext::declarationQualifierErrorCheck(const sh::TQualifier qualifier,
                                                  const sh::TLayoutQualifier &layoutQualifier,
                                                  const TSourceLoc &location)
{
   if (qualifier == EvqShared && !layoutQualifier.isEmpty())
   {
       error(location, "Shared memory declarations cannot have layout specified", "layout");
   }

   if (layoutQualifier.matrixPacking != EmpUnspecified)
   {
       error(location, "layout qualifier only valid for interface blocks",
             getMatrixPackingString(layoutQualifier.matrixPacking));
       return;
   }

   if (layoutQualifier.blockStorage != EbsUnspecified)
   {
       error(location, "layout qualifier only valid for interface blocks",
             getBlockStorageString(layoutQualifier.blockStorage));
       return;
   }

   if (qualifier == EvqFragmentOut)
   {
       if (layoutQualifier.location != -1 && layoutQualifier.yuv == true)
       {
           error(location, "invalid layout qualifier combination", "yuv");
           return;
       }
   }
   else
   {
       checkYuvIsNotSpecified(location, layoutQualifier.yuv);
   }

   if (qualifier != EvqFragmentIn)
   {
       checkEarlyFragmentTestsIsNotSpecified(location, layoutQualifier.earlyFragmentTests);
   }

   // If multiview extension is enabled, "in" qualifier is allowed in the vertex shader in previous
   // parsing steps. So it needs to be checked here.
   if (anyMultiviewExtensionAvailable() && mShaderVersion < 300 && qualifier == EvqVertexIn)
   {
       error(location, "storage qualifier supported in GLSL ES 3.00 and above only", "in");
   }

   bool canHaveLocation = qualifier == EvqVertexIn || qualifier == EvqFragmentOut;
   if (mShaderVersion >= 300 &&
       (isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch) ||
        isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch_non_coherent)))
   {
       // In the case of EXT_shader_framebuffer_fetch or EXT_shader_framebuffer_fetch_non_coherent
       // extension, the location of inout qualifier is used to set the input attachment index
       canHaveLocation = canHaveLocation || qualifier == EvqFragmentInOut;
   }
   if (mShaderVersion >= 310)
   {
       canHaveLocation = canHaveLocation || qualifier == EvqUniform || IsVarying(qualifier);
       // We're not checking whether the uniform location is in range here since that depends on
       // the type of the variable.
       // The type can only be fully determined for non-empty declarations.
   }
   if (!canHaveLocation)
   {
       checkLocationIsNotSpecified(location, layoutQualifier);
   }
}

void TParseContext::atomicCounterQualifierErrorCheck(const TPublicType &publicType,
                                                    const TSourceLoc &location)
{
   if (publicType.precision != EbpHigh)
   {
       error(location, "Can only be highp", "atomic counter");
   }
   // dEQP enforces compile error if location is specified. See uniform_location.test.
   if (publicType.layoutQualifier.location != -1)
   {
       error(location, "location must not be set for atomic_uint", "layout");
   }
   if (publicType.layoutQualifier.binding == -1)
   {
       error(location, "no binding specified", "atomic counter");
   }
}

void TParseContext::emptyDeclarationErrorCheck(const TType &type, const TSourceLoc &location)
{
   if (type.isUnsizedArray())
   {
       // ESSL3 spec section 4.1.9: Array declaration which leaves the size unspecified is an
       // error. It is assumed that this applies to empty declarations as well.
       error(location, "empty array declaration needs to specify a size", "");
   }

   if (type.getQualifier() != EvqFragmentOut)
   {
       checkIndexIsNotSpecified(location, type.getLayoutQualifier().index);
   }
}

// These checks are done for all declarations that are non-empty. They're done for non-empty
// declarations starting a declarator list, and declarators that follow an empty declaration.
void TParseContext::nonEmptyDeclarationErrorCheck(const TPublicType &publicType,
                                                 const TSourceLoc &identifierLocation)
{
   switch (publicType.qualifier)
   {
       case EvqVaryingIn:
       case EvqVaryingOut:
       case EvqAttribute:
       case EvqVertexIn:
       case EvqFragmentOut:
       case EvqFragmentInOut:
       case EvqComputeIn:
           if (publicType.getBasicType() == EbtStruct)
           {
               error(identifierLocation, "cannot be used with a structure",
                     getQualifierString(publicType.qualifier));
               return;
           }
           break;
       case EvqBuffer:
           if (publicType.getBasicType() != EbtInterfaceBlock)
           {
               error(identifierLocation,
                     "cannot declare buffer variables at global scope(outside a block)",
                     getQualifierString(publicType.qualifier));
               return;
           }
           break;
       default:
           break;
   }
   std::string reason(getBasicString(publicType.getBasicType()));
   reason += "s must be uniform";
   if (publicType.qualifier != EvqUniform &&
       !checkIsNotOpaqueType(identifierLocation, publicType.typeSpecifierNonArray, reason.c_str()))
   {
       return;
   }

   if ((publicType.qualifier != EvqTemporary && publicType.qualifier != EvqGlobal &&
        publicType.qualifier != EvqConst) &&
       publicType.getBasicType() == EbtYuvCscStandardEXT)
   {
       error(identifierLocation, "cannot be used with a yuvCscStandardEXT",
             getQualifierString(publicType.qualifier));
       return;
   }

   if (mShaderVersion >= 310 && publicType.qualifier == EvqUniform)
   {
       // Valid uniform declarations can't be unsized arrays since uniforms can't be initialized.
       // But invalid shaders may still reach here with an unsized array declaration.
       TType type(publicType);
       if (!type.isUnsizedArray())
       {
           checkUniformLocationInRange(identifierLocation, type.getLocationCount(),
                                       publicType.layoutQualifier);
       }
   }

   if (mShaderVersion >= 300 && publicType.qualifier == EvqVertexIn)
   {
       // Valid vertex input declarations can't be unsized arrays since they can't be initialized.
       // But invalid shaders may still reach here with an unsized array declaration.
       TType type(publicType);
       if (!type.isUnsizedArray())
       {
           checkAttributeLocationInRange(identifierLocation, type.getLocationCount(),
                                         publicType.layoutQualifier);
       }
   }

   // check for layout qualifier issues
   const TLayoutQualifier layoutQualifier = publicType.layoutQualifier;

   if (IsImage(publicType.getBasicType()))
   {

       switch (layoutQualifier.imageInternalFormat)
       {
           case EiifRGBA32F:
           case EiifRGBA16F:
           case EiifR32F:
           case EiifRGBA8:
           case EiifRGBA8_SNORM:
               if (!IsFloatImage(publicType.getBasicType()))
               {
                   error(identifierLocation,
                         "internal image format requires a floating image type",
                         getBasicString(publicType.getBasicType()));
                   return;
               }
               break;
           case EiifRGBA32I:
           case EiifRGBA16I:
           case EiifRGBA8I:
           case EiifR32I:
               if (!IsIntegerImage(publicType.getBasicType()))
               {
                   error(identifierLocation,
                         "internal image format requires an integer image type",
                         getBasicString(publicType.getBasicType()));
                   return;
               }
               break;
           case EiifRGBA32UI:
           case EiifRGBA16UI:
           case EiifRGBA8UI:
           case EiifR32UI:
               if (!IsUnsignedImage(publicType.getBasicType()))
               {
                   error(identifierLocation,
                         "internal image format requires an unsigned image type",
                         getBasicString(publicType.getBasicType()));
                   return;
               }
               break;
           case EiifUnspecified:
               error(identifierLocation, "layout qualifier", "No image internal format specified");
               return;
           default:
               error(identifierLocation, "layout qualifier", "unrecognized token");
               return;
       }

       // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
       switch (layoutQualifier.imageInternalFormat)
       {
           case EiifR32F:
           case EiifR32I:
           case EiifR32UI:
               break;
           default:
               if (!publicType.memoryQualifier.readonly && !publicType.memoryQualifier.writeonly)
               {
                   error(identifierLocation, "layout qualifier",
                         "Except for images with the r32f, r32i and r32ui format qualifiers, "
                         "image variables must be qualified readonly and/or writeonly");
                   return;
               }
               break;
       }
   }
   else if (IsPixelLocal(publicType.getBasicType()))
   {
       if (getShaderType() != GL_FRAGMENT_SHADER)
       {
           error(identifierLocation,
                 "undefined use of pixel local storage outside a fragment shader",
                 getBasicString(publicType.getBasicType()));
           return;
       }
       switch (layoutQualifier.imageInternalFormat)
       {
           case EiifR32F:
           case EiifRGBA8:
               if (publicType.getBasicType() != EbtPixelLocalANGLE)
               {
                   error(identifierLocation, "pixel local storage format requires pixelLocalANGLE",
                         getImageInternalFormatString(layoutQualifier.imageInternalFormat));
               }
               break;
           case EiifRGBA8I:
               if (publicType.getBasicType() != EbtIPixelLocalANGLE)
               {
                   error(identifierLocation,
                         "pixel local storage format requires ipixelLocalANGLE",
                         getImageInternalFormatString(layoutQualifier.imageInternalFormat));
               }
               break;
           case EiifR32UI:
           case EiifRGBA8UI:
               if (publicType.getBasicType() != EbtUPixelLocalANGLE)
               {
                   error(identifierLocation,
                         "pixel local storage format requires upixelLocalANGLE",
                         getImageInternalFormatString(layoutQualifier.imageInternalFormat));
               }
               break;
           case EiifR32I:
           case EiifRGBA8_SNORM:
           case EiifRGBA16F:
           case EiifRGBA32F:
           case EiifRGBA16I:
           case EiifRGBA32I:
           case EiifRGBA16UI:
           case EiifRGBA32UI:
           default:
               ASSERT(!IsValidWithPixelLocalStorage(layoutQualifier.imageInternalFormat));
               error(identifierLocation, "illegal pixel local storage format",
                     getImageInternalFormatString(layoutQualifier.imageInternalFormat));
               break;
           case EiifUnspecified:
               error(identifierLocation, "pixel local storage requires a format specifier",
                     "layout qualifier");
               break;
       }
       checkMemoryQualifierIsNotSpecified(publicType.memoryQualifier, identifierLocation);
       checkDeclaratorLocationIsNotSpecified(identifierLocation, publicType);
   }
   else
   {
       checkInternalFormatIsNotSpecified(identifierLocation, layoutQualifier.imageInternalFormat);
       checkMemoryQualifierIsNotSpecified(publicType.memoryQualifier, identifierLocation);
   }

   if (IsAtomicCounter(publicType.getBasicType()))
   {
       atomicCounterQualifierErrorCheck(publicType, identifierLocation);
   }
   else
   {
       checkOffsetIsNotSpecified(identifierLocation, layoutQualifier.offset);
   }
}

void TParseContext::checkBindingIsValid(const TSourceLoc &identifierLocation, const TType &type)
{
   TLayoutQualifier layoutQualifier = type.getLayoutQualifier();
   // Note that the ESSL 3.10 section 4.4.5 is not particularly clear on how the binding qualifier
   // on arrays of arrays should be handled. We interpret the spec so that the binding value is
   // incremented for each element of the innermost nested arrays. This is in line with how arrays
   // of arrays of blocks are specified to behave in GLSL 4.50 and a conservative interpretation
   // when it comes to which shaders are accepted by the compiler.
   int arrayTotalElementCount = type.getArraySizeProduct();
   if (IsPixelLocal(type.getBasicType()))
   {
       checkPixelLocalStorageBindingIsValid(identifierLocation, type);
   }
   else if (mShaderVersion < 310)
   {
       checkBindingIsNotSpecified(identifierLocation, layoutQualifier.binding);
   }
   else if (IsImage(type.getBasicType()))
   {
       checkImageBindingIsValid(identifierLocation, layoutQualifier.binding,
                                arrayTotalElementCount);
   }
   else if (IsSampler(type.getBasicType()))
   {
       checkSamplerBindingIsValid(identifierLocation, layoutQualifier.binding,
                                  arrayTotalElementCount);
   }
   else if (IsAtomicCounter(type.getBasicType()))
   {
       checkAtomicCounterBindingIsValid(identifierLocation, layoutQualifier.binding);
   }
   else
   {
       ASSERT(!IsOpaqueType(type.getBasicType()));
       checkBindingIsNotSpecified(identifierLocation, layoutQualifier.binding);
   }
}

void TParseContext::checkCanUseLayoutQualifier(const TSourceLoc &location)
{
   constexpr std::array<TExtension, 4u> extensions{
       {TExtension::EXT_shader_framebuffer_fetch,
        TExtension::EXT_shader_framebuffer_fetch_non_coherent,
        TExtension::KHR_blend_equation_advanced, TExtension::ANGLE_shader_pixel_local_storage}};
   if (getShaderVersion() < 300 && !checkCanUseOneOfExtensions(location, extensions))
   {
       error(location, "qualifier supported in GLSL ES 3.00 and above only", "layout");
   }
}

bool TParseContext::checkLayoutQualifierSupported(const TSourceLoc &location,
                                                 const ImmutableString &layoutQualifierName,
                                                 int versionRequired)
{

   if (mShaderVersion < versionRequired)
   {
       error(location, "invalid layout qualifier: not supported", layoutQualifierName);
       return false;
   }
   return true;
}

bool TParseContext::checkWorkGroupSizeIsNotSpecified(const TSourceLoc &location,
                                                    const TLayoutQualifier &layoutQualifier)
{
   const sh::WorkGroupSize &localSize = layoutQualifier.localSize;
   for (size_t i = 0u; i < localSize.size(); ++i)
   {
       if (localSize[i] != -1)
       {
           error(location,
                 "invalid layout qualifier: only valid when used with 'in' in a compute shader "
                 "global layout declaration",
                 getWorkGroupSizeString(i));
           return false;
       }
   }

   return true;
}

void TParseContext::checkInternalFormatIsNotSpecified(const TSourceLoc &location,
                                                     TLayoutImageInternalFormat internalFormat)
{
   if (internalFormat != EiifUnspecified)
   {
       if (mShaderVersion < 310)
       {
           if (IsValidWithPixelLocalStorage(internalFormat))
           {
               error(location,
                     "invalid layout qualifier: not supported before GLSL ES 3.10, except pixel "
                     "local storage",
                     getImageInternalFormatString(internalFormat));
           }
           else
           {
               error(location, "invalid layout qualifier: not supported before GLSL ES 3.10",
                     getImageInternalFormatString(internalFormat));
           }
       }
       else
       {
           if (IsValidWithPixelLocalStorage(internalFormat))
           {
               error(location,
                     "invalid layout qualifier: only valid when used with images or pixel local "
                     "storage ",
                     getImageInternalFormatString(internalFormat));
           }
           else
           {
               error(location, "invalid layout qualifier: only valid when used with images",
                     getImageInternalFormatString(internalFormat));
           }
       }
   }
}

void TParseContext::checkIndexIsNotSpecified(const TSourceLoc &location, int index)
{
   if (index != -1)
   {
       error(location,
             "invalid layout qualifier: only valid when used with a fragment shader output in "
             "ESSL version >= 3.00 and EXT_blend_func_extended is enabled",
             "index");
   }
}

void TParseContext::checkBindingIsNotSpecified(const TSourceLoc &location, int binding)
{
   if (binding != -1)
   {
       if (mShaderVersion < 310)
       {
           error(location,
                 "invalid layout qualifier: only valid when used with pixel local storage",
                 "binding");
       }
       else
       {
           error(location,
                 "invalid layout qualifier: only valid when used with opaque types or blocks",
                 "binding");
       }
   }
}

void TParseContext::checkOffsetIsNotSpecified(const TSourceLoc &location, int offset)
{
   if (offset != -1)
   {
       error(location, "invalid layout qualifier: only valid when used with atomic counters",
             "offset");
   }
}

void TParseContext::checkImageBindingIsValid(const TSourceLoc &location,
                                            int binding,
                                            int arrayTotalElementCount)
{
   // Expects arraySize to be 1 when setting binding for only a single variable.
   if (binding >= 0 && binding + arrayTotalElementCount > mMaxImageUnits)
   {
       error(location, "image binding greater than gl_MaxImageUnits", "binding");
   }
}

void TParseContext::checkSamplerBindingIsValid(const TSourceLoc &location,
                                              int binding,
                                              int arrayTotalElementCount)
{
   // Expects arraySize to be 1 when setting binding for only a single variable.
   if (binding >= 0 && binding + arrayTotalElementCount > mMaxCombinedTextureImageUnits)
   {
       error(location, "sampler binding greater than maximum texture units", "binding");
   }
}

void TParseContext::checkBlockBindingIsValid(const TSourceLoc &location,
                                            const TQualifier &qualifier,
                                            int binding,
                                            int arraySize)
{
   int size = (arraySize == 0 ? 1 : arraySize);
   if (qualifier == EvqUniform)
   {
       if (binding + size > mMaxUniformBufferBindings)
       {
           error(location, "uniform block binding greater than MAX_UNIFORM_BUFFER_BINDINGS",
                 "binding");
       }
   }
   else if (qualifier == EvqBuffer)
   {
       if (binding + size > mMaxShaderStorageBufferBindings)
       {
           error(location,
                 "shader storage block binding greater than MAX_SHADER_STORAGE_BUFFER_BINDINGS",
                 "binding");
       }
   }
}
void TParseContext::checkAtomicCounterBindingIsValid(const TSourceLoc &location, int binding)
{
   if (binding >= mMaxAtomicCounterBindings)
   {
       error(location, "atomic counter binding greater than gl_MaxAtomicCounterBindings",
             "binding");
   }
}

void TParseContext::checkPixelLocalStorageBindingIsValid(const TSourceLoc &location,
                                                        const TType &type)
{
   TLayoutQualifier layoutQualifier = type.getLayoutQualifier();
   if (type.isArray())
   {
       // PLS is not allowed in arrays.
       // TODO(anglebug.com/7279): Consider allowing this once more backends are implemented.
       error(location, "pixel local storage handles cannot be aggregated in arrays", "array");
   }
   else if (layoutQualifier.binding < 0)
   {
       error(location, "pixel local storage requires a binding index", "layout qualifier");
   }
   // TODO(anglebug.com/7279):
   // else if (binding >= GL_MAX_LOCAL_STORAGE_PLANES_ANGLE)
   // {
   // }
   else if (mPLSBindings.find(layoutQualifier.binding) != mPLSBindings.end())
   {
       error(location, "duplicate pixel local storage binding index",
             std::to_string(layoutQualifier.binding).c_str());
   }
   else
   {
       mPLSBindings[layoutQualifier.binding] = layoutQualifier.imageInternalFormat;
       // "mPLSBindings" is how we know whether pixel local storage uniforms have been declared, so
       // flush the queue of potential errors once mPLSBindings isn't empty.
       if (!mPLSPotentialErrors.empty())
       {
           for (const auto &[loc, op] : mPLSPotentialErrors)
           {
               errorIfPLSDeclared(loc, op);
           }
           mPLSPotentialErrors.clear();
       }
   }
}

void TParseContext::checkUniformLocationInRange(const TSourceLoc &location,
                                               int objectLocationCount,
                                               const TLayoutQualifier &layoutQualifier)
{
   int loc = layoutQualifier.location;
   if (loc >= 0)  // Shader-specified location
   {
       if (loc >= mMaxUniformLocations || objectLocationCount > mMaxUniformLocations ||
           static_cast<unsigned int>(loc) + static_cast<unsigned int>(objectLocationCount) >
               static_cast<unsigned int>(mMaxUniformLocations))
       {
           error(location, "Uniform location out of range", "location");
       }
   }
}

void TParseContext::checkAttributeLocationInRange(const TSourceLoc &location,
                                                 int objectLocationCount,
                                                 const TLayoutQualifier &layoutQualifier)
{
   int loc = layoutQualifier.location;
   if (loc >= 0)  // Shader-specified location
   {
       if (loc >= mMaxVertexAttribs || objectLocationCount > mMaxVertexAttribs ||
           static_cast<unsigned int>(loc) + static_cast<unsigned int>(objectLocationCount) >
               static_cast<unsigned int>(mMaxVertexAttribs))
       {
           error(location, "Attribute location out of range", "location");
       }
   }
}

void TParseContext::checkYuvIsNotSpecified(const TSourceLoc &location, bool yuv)
{
   if (yuv != false)
   {
       error(location, "invalid layout qualifier: only valid on program outputs", "yuv");
   }
}

void TParseContext::checkEarlyFragmentTestsIsNotSpecified(const TSourceLoc &location,
                                                         bool earlyFragmentTests)
{
   if (earlyFragmentTests != false)
   {
       error(location,
             "invalid layout qualifier: only valid when used with 'in' in a fragment shader",
             "early_fragment_tests");
   }
}

void TParseContext::checkNoncoherentIsSpecified(const TSourceLoc &location, bool noncoherent)
{
   if (noncoherent == false)
   {
       error(location,
             "'noncoherent' qualifier must be used when "
             "GL_EXT_shader_framebuffer_fetch_non_coherent extension is used",
             "noncoherent");
   }
}

void TParseContext::checkNoncoherentIsNotSpecified(const TSourceLoc &location, bool noncoherent)
{
   if (noncoherent != false)
   {
       error(location,
             "invalid layout qualifier: only valid when used with 'gl_LastFragData' or the "
             "variable decorated with 'inout' in a fragment shader",
             "noncoherent");
   }
}

void TParseContext::checkTCSOutVarIndexIsValid(TIntermBinary *binaryExpression,
                                              const TSourceLoc &location)
{
   ASSERT(binaryExpression->getOp() == EOpIndexIndirect ||
          binaryExpression->getOp() == EOpIndexDirect);
   const TIntermSymbol *intermSymbol = binaryExpression->getRight()->getAsSymbolNode();
   if ((intermSymbol == nullptr) || (intermSymbol->getName() != "gl_InvocationID"))
   {
       error(location,
             "tessellation-control per-vertex output l-value must be indexed with "
             "gl_InvocationID",
             "[");
   }
}

void TParseContext::functionCallRValueLValueErrorCheck(const TFunction *fnCandidate,
                                                      TIntermAggregate *fnCall)
{
   for (size_t i = 0; i < fnCandidate->getParamCount(); ++i)
   {
       TQualifier qual        = fnCandidate->getParam(i)->getType().getQualifier();
       TIntermTyped *argument = (*(fnCall->getSequence()))[i]->getAsTyped();
       bool argumentIsRead    = (IsQualifierUnspecified(qual) || qual == EvqParamIn ||
                              qual == EvqParamInOut || qual == EvqParamConst);
       if (argumentIsRead)
       {
           markStaticReadIfSymbol(argument);
           if (!IsImage(argument->getBasicType()))
           {
               if (argument->getMemoryQualifier().writeonly)
               {
                   error(argument->getLine(),
                         "Writeonly value cannot be passed for 'in' or 'inout' parameters.",
                         fnCall->functionName());
                   return;
               }
           }
       }
       if (qual == EvqParamOut || qual == EvqParamInOut)
       {
           if (!checkCanBeLValue(argument->getLine(), "assign", argument))
           {
               error(argument->getLine(),
                     "Constant value cannot be passed for 'out' or 'inout' parameters.",
                     fnCall->functionName());
               return;
           }
       }
   }
}

void TParseContext::checkInvariantVariableQualifier(bool invariant,
                                                   const TQualifier qualifier,
                                                   const TSourceLoc &invariantLocation)
{
   if (!invariant)
       return;

   if (mShaderVersion < 300)
   {
       // input variables in the fragment shader can be also qualified as invariant
       if (!sh::CanBeInvariantESSL1(qualifier))
       {
           error(invariantLocation, "Cannot be qualified as invariant.", "invariant");
       }
   }
   else
   {
       if (!sh::CanBeInvariantESSL3OrGreater(qualifier))
       {
           error(invariantLocation, "Cannot be qualified as invariant.", "invariant");
       }
   }
}

void TParseContext::checkAdvancedBlendEquationsNotSpecified(
   const TSourceLoc &location,
   const AdvancedBlendEquations &advancedBlendEquations,
   const TQualifier &qualifier)
{
   if (advancedBlendEquations.any() && qualifier != EvqFragmentOut)
   {
       error(location,
             "invalid layout qualifier: blending equation qualifiers are only permitted on the "
             "fragment 'out' qualifier ",
             "blend_support_qualifier");
   }
}

bool TParseContext::isExtensionEnabled(TExtension extension) const
{
   return IsExtensionEnabled(extensionBehavior(), extension);
}

void TParseContext::handleExtensionDirective(const TSourceLoc &loc,
                                            const char *extName,
                                            const char *behavior)
{
   angle::pp::SourceLocation srcLoc;
   srcLoc.file = loc.first_file;
   srcLoc.line = loc.first_line;
   mDirectiveHandler.handleExtension(srcLoc, extName, behavior);
}

void TParseContext::handlePragmaDirective(const TSourceLoc &loc,
                                         const char *name,
                                         const char *value,
                                         bool stdgl)
{
   angle::pp::SourceLocation srcLoc;
   srcLoc.file = loc.first_file;
   srcLoc.line = loc.first_line;
   mDirectiveHandler.handlePragma(srcLoc, name, value, stdgl);
}

sh::WorkGroupSize TParseContext::getComputeShaderLocalSize() const
{
   sh::WorkGroupSize result(-1);
   for (size_t i = 0u; i < result.size(); ++i)
   {
       if (mComputeShaderLocalSizeDeclared && mComputeShaderLocalSize[i] == -1)
       {
           result[i] = 1;
       }
       else
       {
           result[i] = mComputeShaderLocalSize[i];
       }
   }
   return result;
}

TIntermConstantUnion *TParseContext::addScalarLiteral(const TConstantUnion *constantUnion,
                                                     const TSourceLoc &line)
{
   TIntermConstantUnion *node = new TIntermConstantUnion(
       constantUnion, TType(constantUnion->getType(), EbpUndefined, EvqConst));
   node->setLine(line);
   return node;
}

/////////////////////////////////////////////////////////////////////////////////
//
// Non-Errors.
//
/////////////////////////////////////////////////////////////////////////////////

const TVariable *TParseContext::getNamedVariable(const TSourceLoc &location,
                                                const ImmutableString &name,
                                                const TSymbol *symbol)
{
   if (!symbol)
   {
       error(location, "undeclared identifier", name);
       return nullptr;
   }

   if (!symbol->isVariable())
   {
       error(location, "variable expected", name);
       return nullptr;
   }

   const TVariable *variable = static_cast<const TVariable *>(symbol);

   if (!variable->extensions().empty() && variable->extensions()[0] != TExtension::UNDEFINED)
   {
       checkCanUseOneOfExtensions(location, variable->extensions());
   }

   // GLSL ES 3.1 Revision 4, 7.1.3 Compute Shader Special Variables
   if (getShaderType() == GL_COMPUTE_SHADER && !mComputeShaderLocalSizeDeclared &&
       variable->getType().getQualifier() == EvqWorkGroupSize)
   {
       error(location,
             "It is an error to use gl_WorkGroupSize before declaring the local group size",
             "gl_WorkGroupSize");
   }

   // If EXT_shader_framebuffer_fetch_non_coherent is used, gl_LastFragData should be decorated
   // with 'layout(noncoherent)' EXT_shader_framebuffer_fetch_non_coherent spec: "Unless the
   // GL_EXT_shader_framebuffer_fetch extension  has been enabled in addition, it's an error to use
   // gl_LastFragData if it hasn't been explicitly redeclared with layout(noncoherent)."
   if (isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch_non_coherent) &&
       !isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch) &&
       variable->getType().getQualifier() == EvqLastFragData)
   {
       checkNoncoherentIsSpecified(location, variable->getType().getLayoutQualifier().noncoherent);
   }
   return variable;
}

TIntermTyped *TParseContext::parseVariableIdentifier(const TSourceLoc &location,
                                                    const ImmutableString &name,
                                                    const TSymbol *symbol)
{
   const TVariable *variable = getNamedVariable(location, name, symbol);

   if (!variable)
   {
       TIntermTyped *node = CreateZeroNode(TType(EbtFloat, EbpHigh, EvqConst));
       node->setLine(location);
       return node;
   }

   const TType &variableType = variable->getType();
   TIntermTyped *node        = nullptr;

   if (variable->getConstPointer() && variableType.canReplaceWithConstantUnion())
   {
       const TConstantUnion *constArray = variable->getConstPointer();
       node                             = new TIntermConstantUnion(constArray, variableType);
   }
   else if (variableType.getQualifier() == EvqWorkGroupSize && mComputeShaderLocalSizeDeclared)
   {
       // gl_WorkGroupSize can be used to size arrays according to the ESSL 3.10.4 spec, so it
       // needs to be added to the AST as a constant and not as a symbol.
       sh::WorkGroupSize workGroupSize = getComputeShaderLocalSize();
       TConstantUnion *constArray      = new TConstantUnion[3];
       for (size_t i = 0; i < 3; ++i)
       {
           constArray[i].setUConst(static_cast<unsigned int>(workGroupSize[i]));
       }

       ASSERT(variableType.getBasicType() == EbtUInt);
       ASSERT(variableType.getObjectSize() == 3);

       TType type(variableType);
       type.setQualifier(EvqConst);
       node = new TIntermConstantUnion(constArray, type);
   }
   else if ((mGeometryShaderInputPrimitiveType != EptUndefined) &&
            (variableType.getQualifier() == EvqPerVertexIn))
   {
       ASSERT(symbolTable.getGlInVariableWithArraySize() != nullptr);
       node = new TIntermSymbol(symbolTable.getGlInVariableWithArraySize());
   }
   else
   {
       node = new TIntermSymbol(variable);
   }
   ASSERT(node != nullptr);
   node->setLine(location);
   return node;
}

void TParseContext::adjustRedeclaredBuiltInType(const ImmutableString &identifier, TType *type)
{
   if (identifier == "gl_ClipDistance")
   {
       type->setQualifier(EvqClipDistance);
   }
   else if (identifier == "gl_CullDistance")
   {
       type->setQualifier(EvqCullDistance);
   }
   else if (identifier == "gl_LastFragData")
   {
       type->setQualifier(EvqLastFragData);
   }
}

// Initializers show up in several places in the grammar.  Have one set of
// code to handle them here.
//
// Returns true on success.
bool TParseContext::executeInitializer(const TSourceLoc &line,
                                      const ImmutableString &identifier,
                                      TType *type,
                                      TIntermTyped *initializer,
                                      TIntermBinary **initNode)
{
   ASSERT(initNode != nullptr);
   ASSERT(*initNode == nullptr);

   if (type->isUnsizedArray())
   {
       // In case initializer is not an array or type has more dimensions than initializer, this
       // will default to setting array sizes to 1. We have not checked yet whether the initializer
       // actually is an array or not. Having a non-array initializer for an unsized array will
       // result in an error later, so we don't generate an error message here.
       type->sizeUnsizedArrays(initializer->getType().getArraySizes());
   }

   const TQualifier qualifier = type->getQualifier();

   bool constError = false;
   if (qualifier == EvqConst)
   {
       if (EvqConst != initializer->getType().getQualifier())
       {
           TInfoSinkBase reasonStream;
           reasonStream << "assigning non-constant to '" << *type << "'";
           error(line, reasonStream.c_str(), "=");

           // We're still going to declare the variable to avoid extra error messages.
           type->setQualifier(EvqTemporary);
           constError = true;
       }
   }

   TVariable *variable = nullptr;
   if (!declareVariable(line, identifier, type, &variable))
   {
       return false;
   }

   if (constError)
   {
       return false;
   }

   bool nonConstGlobalInitializers =
       IsExtensionEnabled(mDirectiveHandler.extensionBehavior(),
                          TExtension::EXT_shader_non_constant_global_initializers);
   bool globalInitWarning = false;
   if (symbolTable.atGlobalLevel() &&
       !ValidateGlobalInitializer(initializer, mShaderVersion, sh::IsWebGLBasedSpec(mShaderSpec),
                                  nonConstGlobalInitializers, &globalInitWarning))
   {
       // Error message does not completely match behavior with ESSL 1.00, but
       // we want to steer developers towards only using constant expressions.
       error(line, "global variable initializers must be constant expressions", "=");
       return false;
   }
   if (globalInitWarning)
   {
       warning(
           line,
           "global variable initializers should be constant expressions "
           "(uniforms and globals are allowed in global initializers for legacy compatibility)",
           "=");
   }

   // identifier must be of type constant, a global, or a temporary
   if ((qualifier != EvqTemporary) && (qualifier != EvqGlobal) && (qualifier != EvqConst))
   {
       error(line, " cannot initialize this type of qualifier ",
             variable->getType().getQualifierString());
       return false;
   }

   TIntermSymbol *intermSymbol = new TIntermSymbol(variable);
   intermSymbol->setLine(line);

   if (!binaryOpCommonCheck(EOpInitialize, intermSymbol, initializer, line))
   {
       assignError(line, "=", variable->getType(), initializer->getType());
       return false;
   }

   if (qualifier == EvqConst)
   {
       // Save the constant folded value to the variable if possible.
       const TConstantUnion *constArray = initializer->getConstantValue();
       if (constArray)
       {
           variable->shareConstPointer(constArray);
           if (initializer->getType().canReplaceWithConstantUnion())
           {
               ASSERT(*initNode == nullptr);
               return true;
           }
       }
   }

   *initNode = new TIntermBinary(EOpInitialize, intermSymbol, initializer);
   markStaticReadIfSymbol(initializer);
   (*initNode)->setLine(line);
   return true;
}

TIntermNode *TParseContext::addConditionInitializer(const TPublicType &pType,
                                                   const ImmutableString &identifier,
                                                   TIntermTyped *initializer,
                                                   const TSourceLoc &loc)
{
   checkIsScalarBool(loc, pType);
   TIntermBinary *initNode = nullptr;
   TType *type             = new TType(pType);
   if (executeInitializer(loc, identifier, type, initializer, &initNode))
   {
       // The initializer is valid. The init condition needs to have a node - either the
       // initializer node, or a constant node in case the initialized variable is const and won't
       // be recorded in the AST.
       if (initNode == nullptr)
       {
           return initializer;
       }
       else
       {
           TIntermDeclaration *declaration = new TIntermDeclaration();
           declaration->appendDeclarator(initNode);
           return declaration;
       }
   }
   return nullptr;
}

TIntermNode *TParseContext::addLoop(TLoopType type,
                                   TIntermNode *init,
                                   TIntermNode *cond,
                                   TIntermTyped *expr,
                                   TIntermNode *body,
                                   const TSourceLoc &line)
{
   TIntermNode *node       = nullptr;
   TIntermTyped *typedCond = nullptr;
   if (cond)
   {
       markStaticReadIfSymbol(cond);
       typedCond = cond->getAsTyped();
   }
   if (expr)
   {
       markStaticReadIfSymbol(expr);
   }
   // In case the loop body was not parsed as a block and contains a statement that simply refers
   // to a variable, we need to mark it as statically used.
   if (body)
   {
       markStaticReadIfSymbol(body);
   }
   if (cond == nullptr || typedCond)
   {
       if (type == ELoopDoWhile && typedCond)
       {
           checkIsScalarBool(line, typedCond);
       }
       // In the case of other loops, it was checked before that the condition is a scalar boolean.
       ASSERT(mDiagnostics->numErrors() > 0 || typedCond == nullptr ||
              (typedCond->getBasicType() == EbtBool && !typedCond->isArray() &&
               !typedCond->isVector()));

       node = new TIntermLoop(type, init, typedCond, expr, EnsureBlock(body));
       node->setLine(line);
       return node;
   }

   ASSERT(type != ELoopDoWhile);

   TIntermDeclaration *declaration = cond->getAsDeclarationNode();
   ASSERT(declaration);
   TIntermBinary *declarator = declaration->getSequence()->front()->getAsBinaryNode();
   ASSERT(declarator->getLeft()->getAsSymbolNode());

   // The condition is a declaration. In the AST representation we don't support declarations as
   // loop conditions. Wrap the loop to a block that declares the condition variable and contains
   // the loop.
   TIntermBlock *block = new TIntermBlock();

   TIntermDeclaration *declareCondition = new TIntermDeclaration();
   declareCondition->appendDeclarator(declarator->getLeft()->deepCopy());
   block->appendStatement(declareCondition);

   TIntermBinary *conditionInit = new TIntermBinary(EOpAssign, declarator->getLeft()->deepCopy(),
                                                    declarator->getRight()->deepCopy());
   TIntermLoop *loop = new TIntermLoop(type, init, conditionInit, expr, EnsureBlock(body));
   block->appendStatement(loop);
   loop->setLine(line);
   block->setLine(line);
   return block;
}

TIntermNode *TParseContext::addIfElse(TIntermTyped *cond,
                                     TIntermNodePair code,
                                     const TSourceLoc &loc)
{
   bool isScalarBool = checkIsScalarBool(loc, cond);
   // In case the conditional statements were not parsed as blocks and contain a statement that
   // simply refers to a variable, we need to mark them as statically used.
   if (code.node1)
   {
       markStaticReadIfSymbol(code.node1);
   }
   if (code.node2)
   {
       markStaticReadIfSymbol(code.node2);
   }

   // For compile time constant conditions, prune the code now.
   if (isScalarBool && cond->getAsConstantUnion())
   {
       if (cond->getAsConstantUnion()->getBConst(0) == true)
       {
           return EnsureBlock(code.node1);
       }
       else
       {
           return EnsureBlock(code.node2);
       }
   }

   TIntermIfElse *node = new TIntermIfElse(cond, EnsureBlock(code.node1), EnsureBlock(code.node2));
   markStaticReadIfSymbol(cond);
   node->setLine(loc);

   return node;
}

void TParseContext::addFullySpecifiedType(TPublicType *typeSpecifier)
{
   checkPrecisionSpecified(typeSpecifier->getLine(), typeSpecifier->precision,
                           typeSpecifier->getBasicType());

   if (mShaderVersion < 300 && typeSpecifier->isArray())
   {
       error(typeSpecifier->getLine(), "not supported", "first-class array");
       typeSpecifier->clearArrayness();
   }
}

TPublicType TParseContext::addFullySpecifiedType(const TTypeQualifierBuilder &typeQualifierBuilder,
                                                const TPublicType &typeSpecifier)
{
   TTypeQualifier typeQualifier = typeQualifierBuilder.getVariableTypeQualifier(mDiagnostics);

   TPublicType returnType     = typeSpecifier;
   returnType.qualifier       = typeQualifier.qualifier;
   returnType.invariant       = typeQualifier.invariant;
   returnType.precise         = typeQualifier.precise;
   returnType.layoutQualifier = typeQualifier.layoutQualifier;
   returnType.memoryQualifier = typeQualifier.memoryQualifier;
   returnType.precision       = typeSpecifier.precision;

   if (typeQualifier.precision != EbpUndefined)
   {
       returnType.precision = typeQualifier.precision;
   }

   checkPrecisionSpecified(typeSpecifier.getLine(), returnType.precision,
                           typeSpecifier.getBasicType());

   checkInvariantVariableQualifier(returnType.invariant, returnType.qualifier,
                                   typeSpecifier.getLine());

   checkWorkGroupSizeIsNotSpecified(typeSpecifier.getLine(), returnType.layoutQualifier);

   checkEarlyFragmentTestsIsNotSpecified(typeSpecifier.getLine(),
                                         returnType.layoutQualifier.earlyFragmentTests);

   if (returnType.qualifier == EvqSampleIn || returnType.qualifier == EvqSampleOut)
   {
       mSampleQualifierSpecified = true;
   }

   if (mShaderVersion < 300)
   {
       if (typeSpecifier.isArray())
       {
           error(typeSpecifier.getLine(), "not supported", "first-class array");
           returnType.clearArrayness();
       }

       if (returnType.qualifier == EvqAttribute &&
           (typeSpecifier.getBasicType() == EbtBool || typeSpecifier.getBasicType() == EbtInt))
       {
           error(typeSpecifier.getLine(), "cannot be bool or int",
                 getQualifierString(returnType.qualifier));
       }

       if ((returnType.qualifier == EvqVaryingIn || returnType.qualifier == EvqVaryingOut) &&
           (typeSpecifier.getBasicType() == EbtBool || typeSpecifier.getBasicType() == EbtInt))
       {
           error(typeSpecifier.getLine(), "cannot be bool or int",
                 getQualifierString(returnType.qualifier));
       }
   }
   else
   {
       if (!returnType.layoutQualifier.isEmpty())
       {
           checkIsAtGlobalLevel(typeSpecifier.getLine(), "layout");
       }
       if (sh::IsVarying(returnType.qualifier) || returnType.qualifier == EvqVertexIn ||
           returnType.qualifier == EvqFragmentOut || returnType.qualifier == EvqFragmentInOut)
       {
           checkInputOutputTypeIsValidES3(returnType.qualifier, typeSpecifier,
                                          typeSpecifier.getLine());
       }
       if (returnType.qualifier == EvqComputeIn)
       {
           error(typeSpecifier.getLine(), "'in' can be only used to specify the local group size",
                 "in");
       }
   }

   return returnType;
}

void TParseContext::checkInputOutputTypeIsValidES3(const TQualifier qualifier,
                                                  const TPublicType &type,
                                                  const TSourceLoc &qualifierLocation)
{
   // An input/output variable can never be bool or a sampler. Samplers are checked elsewhere.
   if (type.getBasicType() == EbtBool)
   {
       error(qualifierLocation, "cannot be bool", getQualifierString(qualifier));
   }

   // Specific restrictions apply for vertex shader inputs and fragment shader outputs.
   switch (qualifier)
   {
       case EvqVertexIn:
           // ESSL 3.00 section 4.3.4
           if (type.isArray())
           {
               error(qualifierLocation, "cannot be array", getQualifierString(qualifier));
           }
           // Vertex inputs with a struct type are disallowed in nonEmptyDeclarationErrorCheck
           return;
       case EvqFragmentOut:
       case EvqFragmentInOut:
           // ESSL 3.00 section 4.3.6
           if (type.typeSpecifierNonArray.isMatrix())
           {
               error(qualifierLocation, "cannot be matrix", getQualifierString(qualifier));
           }
           // Fragment outputs with a struct type are disallowed in nonEmptyDeclarationErrorCheck
           return;
       default:
           break;
   }

   // Vertex shader outputs / fragment shader inputs have a different, slightly more lenient set of
   // restrictions.
   bool typeContainsIntegers =
       (type.getBasicType() == EbtInt || type.getBasicType() == EbtUInt ||
        type.isStructureContainingType(EbtInt) || type.isStructureContainingType(EbtUInt));
   bool extendedShaderTypes = mShaderVersion >= 320 ||
                              isExtensionEnabled(TExtension::EXT_geometry_shader) ||
                              isExtensionEnabled(TExtension::OES_geometry_shader) ||
                              isExtensionEnabled(TExtension::EXT_tessellation_shader);
   if (typeContainsIntegers && qualifier != EvqFlatIn && qualifier != EvqFlatOut &&
       (!extendedShaderTypes || mShaderType == GL_FRAGMENT_SHADER))
   {
       error(qualifierLocation, "must use 'flat' interpolation here",
             getQualifierString(qualifier));
   }

   if (type.getBasicType() == EbtStruct)
   {
       // ESSL 3.00 sections 4.3.4 and 4.3.6.
       // These restrictions are only implied by the ESSL 3.00 spec, but
       // the ESSL 3.10 spec lists these restrictions explicitly.
       if (type.isArray())
       {
           error(qualifierLocation, "cannot be an array of structures",
                 getQualifierString(qualifier));
       }
       if (type.isStructureContainingArrays())
       {
           error(qualifierLocation, "cannot be a structure containing an array",
                 getQualifierString(qualifier));
       }
       if (type.isStructureContainingType(EbtStruct))
       {
           error(qualifierLocation, "cannot be a structure containing a structure",
                 getQualifierString(qualifier));
       }
       if (type.isStructureContainingType(EbtBool))
       {
           error(qualifierLocation, "cannot be a structure containing a bool",
                 getQualifierString(qualifier));
       }
   }
}

void TParseContext::checkLocalVariableConstStorageQualifier(const TQualifierWrapperBase &qualifier)
{
   if (qualifier.getType() == QtStorage)
   {
       const TStorageQualifierWrapper &storageQualifier =
           static_cast<const TStorageQualifierWrapper &>(qualifier);
       if (!declaringFunction() && storageQualifier.getQualifier() != EvqConst &&
           !symbolTable.atGlobalLevel())
       {
           error(storageQualifier.getLine(),
                 "Local variables can only use the const storage qualifier.",
                 storageQualifier.getQualifierString());
       }
   }
}

void TParseContext::checkMemoryQualifierIsNotSpecified(const TMemoryQualifier &memoryQualifier,
                                                      const TSourceLoc &location)
{
   const std::string reason(
       "Only allowed with shader storage blocks, variables declared within shader storage blocks "
       "and variables declared as image types.");
   if (memoryQualifier.readonly)
   {
       error(location, reason.c_str(), "readonly");
   }
   if (memoryQualifier.writeonly)
   {
       error(location, reason.c_str(), "writeonly");
   }
   if (memoryQualifier.coherent)
   {
       error(location, reason.c_str(), "coherent");
   }
   if (memoryQualifier.restrictQualifier)
   {
       error(location, reason.c_str(), "restrict");
   }
   if (memoryQualifier.volatileQualifier)
   {
       error(location, reason.c_str(), "volatile");
   }
}

// Make sure there is no offset overlapping, and store the newly assigned offset to "type" in
// intermediate tree.
void TParseContext::checkAtomicCounterOffsetDoesNotOverlap(bool forceAppend,
                                                          const TSourceLoc &loc,
                                                          TType *type)
{
   const size_t size = type->isArray() ? kAtomicCounterArrayStride * type->getArraySizeProduct()
                                       : kAtomicCounterSize;
   TLayoutQualifier layoutQualifier = type->getLayoutQualifier();
   auto &bindingState               = mAtomicCounterBindingStates[layoutQualifier.binding];
   int offset;
   if (layoutQualifier.offset == -1 || forceAppend)
   {
       offset = bindingState.appendSpan(size);
   }
   else
   {
       offset = bindingState.insertSpan(layoutQualifier.offset, size);
   }
   if (offset == -1)
   {
       error(loc, "Offset overlapping", "atomic counter");
       return;
   }
   layoutQualifier.offset = offset;
   type->setLayoutQualifier(layoutQualifier);
}

void TParseContext::checkAtomicCounterOffsetAlignment(const TSourceLoc &location, const TType &type)
{
   TLayoutQualifier layoutQualifier = type.getLayoutQualifier();

   // OpenGL ES 3.1 Table 6.5, Atomic counter offset must be a multiple of 4
   if (layoutQualifier.offset % 4 != 0)
   {
       error(location, "Offset must be multiple of 4", "atomic counter");
   }
}

void TParseContext::checkGeometryShaderInputAndSetArraySize(const TSourceLoc &location,
                                                           const ImmutableString &token,
                                                           TType *type)
{
   if (IsGeometryShaderInput(mShaderType, type->getQualifier()))
   {
       if (type->isArray() && type->getOutermostArraySize() == 0u)
       {
           // Set size for the unsized geometry shader inputs if they are declared after a valid
           // input primitive declaration.
           if (mGeometryShaderInputPrimitiveType != EptUndefined)
           {
               ASSERT(symbolTable.getGlInVariableWithArraySize() != nullptr);
               type->sizeOutermostUnsizedArray(
                   symbolTable.getGlInVariableWithArraySize()->getType().getOutermostArraySize());
           }
           else
           {
               // [GLSL ES 3.2 SPEC Chapter 4.4.1.2]
               // An input can be declared without an array size if there is a previous layout
               // which specifies the size.
               warning(location,
                       "Missing a valid input primitive declaration before declaring an unsized "
                       "array input",
                       "Deferred");
               mDeferredArrayTypesToSize.push_back(type);
           }
       }
       else if (type->isArray())
       {
           setGeometryShaderInputArraySize(type->getOutermostArraySize(), location);
       }
       else
       {
           error(location, "Geometry shader input variable must be declared as an array", token);
       }
   }
}

void TParseContext::checkTessellationShaderUnsizedArraysAndSetSize(const TSourceLoc &location,
                                                                  const ImmutableString &token,
                                                                  TType *type)
{
   TQualifier qualifier = type->getQualifier();
   if (!IsTessellationControlShaderOutput(mShaderType, qualifier) &&
       !IsTessellationControlShaderInput(mShaderType, qualifier) &&
       !IsTessellationEvaluationShaderInput(mShaderType, qualifier))
   {
       return;
   }

   // Such variables must be declared as arrays or inside output blocks declared as arrays.
   if (!type->isArray())
   {
       error(location, "Tessellation interface variables must be declared as an array", token);
       return;
   }

   // If a size is specified, it must match the maximum patch size.
   unsigned int outermostSize = type->getOutermostArraySize();
   if (outermostSize == 0u)
   {
       switch (qualifier)
       {
           case EvqTessControlIn:
           case EvqTessEvaluationIn:
           case EvqFlatIn:
           case EvqCentroidIn:
           case EvqSmoothIn:
           case EvqSampleIn:
               // Declaring an array size is optional. If no size is specified, it will be taken
               // from the implementation-dependent maximum patch size (gl_MaxPatchVertices).
               ASSERT(mMaxPatchVertices > 0);
               type->sizeOutermostUnsizedArray(mMaxPatchVertices);
               break;
           case EvqTessControlOut:
           case EvqFlatOut:
           case EvqCentroidOut:
           case EvqSmoothOut:
           case EvqSampleOut:
               // Declaring an array size is optional. If no size is specified, it will be taken
               // from output patch size declared in the shader.  If the patch size is not yet
               // declared, this is deferred until such time as it does.
               if (mTessControlShaderOutputVertices == 0)
               {
                   mDeferredArrayTypesToSize.push_back(type);
               }
               else
               {
                   type->sizeOutermostUnsizedArray(mTessControlShaderOutputVertices);
               }
               break;
           default:
               UNREACHABLE();
               break;
       }
       return;
   }

   if (IsTessellationControlShaderInput(mShaderType, qualifier) ||
       IsTessellationEvaluationShaderInput(mShaderType, qualifier))
   {
       if (outermostSize != static_cast<unsigned int>(mMaxPatchVertices))
       {
           error(location,
                 "If a size is specified for a tessellation control or evaluation user-defined "
                 "input variable, it must match the maximum patch size (gl_MaxPatchVertices).",
                 token);
       }
   }
   else if (IsTessellationControlShaderOutput(mShaderType, qualifier))
   {
       if (outermostSize != static_cast<unsigned int>(mTessControlShaderOutputVertices) &&
           mTessControlShaderOutputVertices != 0)
       {
           error(location,
                 "If a size is specified for a tessellation control user-defined per-vertex "
                 "output variable, it must match the the number of vertices in the output "
                 "patch.",
                 token);
       }
   }
}

TIntermDeclaration *TParseContext::parseSingleDeclaration(
   TPublicType &publicType,
   const TSourceLoc &identifierOrTypeLocation,
   const ImmutableString &identifier)
{
   TType *type = new TType(publicType);
   if (mCompileOptions.flattenPragmaSTDGLInvariantAll &&
       mDirectiveHandler.pragma().stdgl.invariantAll)
   {
       TQualifier qualifier = type->getQualifier();

       // The directive handler has already taken care of rejecting invalid uses of this pragma
       // (for example, in ESSL 3.00 fragment shaders), so at this point, flatten it into all
       // affected variable declarations:
       //
       // 1. Built-in special variables which are inputs to the fragment shader. (These are handled
       // elsewhere, in TranslatorGLSL.)
       //
       // 2. Outputs from vertex shaders in ESSL 1.00 and 3.00 (EvqVaryingOut and EvqVertexOut). It
       // is actually less likely that there will be bugs in the handling of ESSL 3.00 shaders, but
       // the way this is currently implemented we have to enable this compiler option before
       // parsing the shader and determining the shading language version it uses. If this were
       // implemented as a post-pass, the workaround could be more targeted.
       if (qualifier == EvqVaryingOut || qualifier == EvqVertexOut)
       {
           type->setInvariant(true);
       }
   }

   checkGeometryShaderInputAndSetArraySize(identifierOrTypeLocation, identifier, type);
   checkTessellationShaderUnsizedArraysAndSetSize(identifierOrTypeLocation, identifier, type);

   declarationQualifierErrorCheck(publicType.qualifier, publicType.layoutQualifier,
                                  identifierOrTypeLocation);

   bool emptyDeclaration                  = (identifier == "");
   mDeferredNonEmptyDeclarationErrorCheck = emptyDeclaration;

   TIntermSymbol *symbol = nullptr;
   if (emptyDeclaration)
   {
       emptyDeclarationErrorCheck(*type, identifierOrTypeLocation);
       // In most cases we don't need to create a symbol node for an empty declaration.
       // But if the empty declaration is declaring a struct type, the symbol node will store that.
       if (type->getBasicType() == EbtStruct)
       {
           TVariable *emptyVariable =
               new TVariable(&symbolTable, kEmptyImmutableString, type, SymbolType::Empty);
           symbol = new TIntermSymbol(emptyVariable);
       }
       else if (IsAtomicCounter(publicType.getBasicType()))
       {
           setAtomicCounterBindingDefaultOffset(publicType, identifierOrTypeLocation);
       }
   }
   else
   {
       nonEmptyDeclarationErrorCheck(publicType, identifierOrTypeLocation);

       checkCanBeDeclaredWithoutInitializer(identifierOrTypeLocation, identifier, type);

       if (IsAtomicCounter(type->getBasicType()))
       {
           checkAtomicCounterOffsetDoesNotOverlap(false, identifierOrTypeLocation, type);

           checkAtomicCounterOffsetAlignment(identifierOrTypeLocation, *type);
       }

       TVariable *variable = nullptr;
       if (declareVariable(identifierOrTypeLocation, identifier, type, &variable))
       {
           symbol = new TIntermSymbol(variable);
       }
   }

   TIntermDeclaration *declaration = new TIntermDeclaration();
   declaration->setLine(identifierOrTypeLocation);
   if (symbol)
   {
       symbol->setLine(identifierOrTypeLocation);
       declaration->appendDeclarator(symbol);
   }
   return declaration;
}

TIntermDeclaration *TParseContext::parseSingleArrayDeclaration(
   TPublicType &elementType,
   const TSourceLoc &identifierLocation,
   const ImmutableString &identifier,
   const TSourceLoc &indexLocation,
   const TVector<unsigned int> &arraySizes)
{
   mDeferredNonEmptyDeclarationErrorCheck = false;

   declarationQualifierErrorCheck(elementType.qualifier, elementType.layoutQualifier,
                                  identifierLocation);

   nonEmptyDeclarationErrorCheck(elementType, identifierLocation);

   checkIsValidTypeAndQualifierForArray(indexLocation, elementType);

   TType *arrayType = new TType(elementType);
   arrayType->makeArrays(arraySizes);

   checkArrayOfArraysInOut(indexLocation, elementType, *arrayType);

   checkGeometryShaderInputAndSetArraySize(indexLocation, identifier, arrayType);
   checkTessellationShaderUnsizedArraysAndSetSize(indexLocation, identifier, arrayType);

   checkCanBeDeclaredWithoutInitializer(identifierLocation, identifier, arrayType);

   if (IsAtomicCounter(arrayType->getBasicType()))
   {
       checkAtomicCounterOffsetDoesNotOverlap(false, identifierLocation, arrayType);

       checkAtomicCounterOffsetAlignment(identifierLocation, *arrayType);
   }

   adjustRedeclaredBuiltInType(identifier, arrayType);

   TIntermDeclaration *declaration = new TIntermDeclaration();
   declaration->setLine(identifierLocation);

   TVariable *variable = nullptr;
   if (declareVariable(identifierLocation, identifier, arrayType, &variable))
   {
       TIntermSymbol *symbol = new TIntermSymbol(variable);
       symbol->setLine(identifierLocation);
       declaration->appendDeclarator(symbol);
   }

   return declaration;
}

TIntermDeclaration *TParseContext::parseSingleInitDeclaration(const TPublicType &publicType,
                                                             const TSourceLoc &identifierLocation,
                                                             const ImmutableString &identifier,
                                                             const TSourceLoc &initLocation,
                                                             TIntermTyped *initializer)
{
   mDeferredNonEmptyDeclarationErrorCheck = false;

   declarationQualifierErrorCheck(publicType.qualifier, publicType.layoutQualifier,
                                  identifierLocation);

   nonEmptyDeclarationErrorCheck(publicType, identifierLocation);

   TIntermDeclaration *declaration = new TIntermDeclaration();
   declaration->setLine(identifierLocation);

   TIntermBinary *initNode = nullptr;
   TType *type             = new TType(publicType);
   if (executeInitializer(identifierLocation, identifier, type, initializer, &initNode))
   {
       if (initNode)
       {
           declaration->appendDeclarator(initNode);
       }
       else if (publicType.isStructSpecifier())
       {
           // The initialization got constant folded.  If it's a struct, declare the struct anyway.
           TVariable *emptyVariable =
               new TVariable(&symbolTable, kEmptyImmutableString, type, SymbolType::Empty);
           TIntermSymbol *symbol = new TIntermSymbol(emptyVariable);
           symbol->setLine(publicType.getLine());
           declaration->appendDeclarator(symbol);
       }
   }
   return declaration;
}

TIntermDeclaration *TParseContext::parseSingleArrayInitDeclaration(
   TPublicType &elementType,
   const TSourceLoc &identifierLocation,
   const ImmutableString &identifier,
   const TSourceLoc &indexLocation,
   const TVector<unsigned int> &arraySizes,
   const TSourceLoc &initLocation,
   TIntermTyped *initializer)
{
   mDeferredNonEmptyDeclarationErrorCheck = false;

   declarationQualifierErrorCheck(elementType.qualifier, elementType.layoutQualifier,
                                  identifierLocation);

   nonEmptyDeclarationErrorCheck(elementType, identifierLocation);

   checkIsValidTypeAndQualifierForArray(indexLocation, elementType);

   TType *arrayType = new TType(elementType);
   arrayType->makeArrays(arraySizes);

   TIntermDeclaration *declaration = new TIntermDeclaration();
   declaration->setLine(identifierLocation);

   // initNode will correspond to the whole of "type b[n] = initializer".
   TIntermBinary *initNode = nullptr;
   if (executeInitializer(identifierLocation, identifier, arrayType, initializer, &initNode))
   {
       if (initNode)
       {
           declaration->appendDeclarator(initNode);
       }
   }

   return declaration;
}

TIntermGlobalQualifierDeclaration *TParseContext::parseGlobalQualifierDeclaration(
   const TTypeQualifierBuilder &typeQualifierBuilder,
   const TSourceLoc &identifierLoc,
   const ImmutableString &identifier,
   const TSymbol *symbol)
{
   TTypeQualifier typeQualifier = typeQualifierBuilder.getVariableTypeQualifier(mDiagnostics);

   if (!typeQualifier.invariant && !typeQualifier.precise)
   {
       error(identifierLoc, "Expected invariant or precise", identifier);
       return nullptr;
   }
   if (typeQualifier.invariant && !checkIsAtGlobalLevel(identifierLoc, "invariant varying"))
   {
       return nullptr;
   }
   if (!symbol)
   {
       error(identifierLoc, "undeclared identifier declared as invariant or precise", identifier);
       return nullptr;
   }
   if (!IsQualifierUnspecified(typeQualifier.qualifier))
   {
       error(identifierLoc, "invariant or precise declaration specifies qualifier",
             getQualifierString(typeQualifier.qualifier));
   }
   if (typeQualifier.precision != EbpUndefined)
   {
       error(identifierLoc, "invariant or precise declaration specifies precision",
             getPrecisionString(typeQualifier.precision));
   }
   if (!typeQualifier.layoutQualifier.isEmpty())
   {
       error(identifierLoc, "invariant or precise declaration specifies layout", "'layout'");
   }

   const TVariable *variable = getNamedVariable(identifierLoc, identifier, symbol);
   if (!variable)
   {
       return nullptr;
   }
   const TType &type = variable->getType();

   checkInvariantVariableQualifier(typeQualifier.invariant, type.getQualifier(),
                                   typeQualifier.line);
   checkMemoryQualifierIsNotSpecified(typeQualifier.memoryQualifier, typeQualifier.line);

   symbolTable.addInvariantVarying(*variable);

   TIntermSymbol *intermSymbol = new TIntermSymbol(variable);
   intermSymbol->setLine(identifierLoc);

   return new TIntermGlobalQualifierDeclaration(intermSymbol, typeQualifier.precise,
                                                identifierLoc);
}

void TParseContext::parseDeclarator(TPublicType &publicType,
                                   const TSourceLoc &identifierLocation,
                                   const ImmutableString &identifier,
                                   TIntermDeclaration *declarationOut)
{
   // If the declaration starting this declarator list was empty (example: int,), some checks were
   // not performed.
   if (mDeferredNonEmptyDeclarationErrorCheck)
   {
       nonEmptyDeclarationErrorCheck(publicType, identifierLocation);
       mDeferredNonEmptyDeclarationErrorCheck = false;
   }

   checkDeclaratorLocationIsNotSpecified(identifierLocation, publicType);

   TType *type = new TType(publicType);

   checkGeometryShaderInputAndSetArraySize(identifierLocation, identifier, type);
   checkTessellationShaderUnsizedArraysAndSetSize(identifierLocation, identifier, type);

   checkCanBeDeclaredWithoutInitializer(identifierLocation, identifier, type);

   if (IsAtomicCounter(type->getBasicType()))
   {
       checkAtomicCounterOffsetDoesNotOverlap(true, identifierLocation, type);

       checkAtomicCounterOffsetAlignment(identifierLocation, *type);
   }

   adjustRedeclaredBuiltInType(identifier, type);

   TVariable *variable = nullptr;
   if (declareVariable(identifierLocation, identifier, type, &variable))
   {
       TIntermSymbol *symbol = new TIntermSymbol(variable);
       symbol->setLine(identifierLocation);
       declarationOut->appendDeclarator(symbol);
   }
}

void TParseContext::parseArrayDeclarator(TPublicType &elementType,
                                        const TSourceLoc &identifierLocation,
                                        const ImmutableString &identifier,
                                        const TSourceLoc &arrayLocation,
                                        const TVector<unsigned int> &arraySizes,
                                        TIntermDeclaration *declarationOut)
{
   // If the declaration starting this declarator list was empty (example: int,), some checks were
   // not performed.
   if (mDeferredNonEmptyDeclarationErrorCheck)
   {
       nonEmptyDeclarationErrorCheck(elementType, identifierLocation);
       mDeferredNonEmptyDeclarationErrorCheck = false;
   }

   checkDeclaratorLocationIsNotSpecified(identifierLocation, elementType);

   if (checkIsValidTypeAndQualifierForArray(arrayLocation, elementType))
   {
       TType *arrayType = new TType(elementType);
       arrayType->makeArrays(arraySizes);

       checkGeometryShaderInputAndSetArraySize(identifierLocation, identifier, arrayType);
       checkTessellationShaderUnsizedArraysAndSetSize(identifierLocation, identifier, arrayType);

       checkCanBeDeclaredWithoutInitializer(identifierLocation, identifier, arrayType);

       if (IsAtomicCounter(arrayType->getBasicType()))
       {
           checkAtomicCounterOffsetDoesNotOverlap(true, identifierLocation, arrayType);

           checkAtomicCounterOffsetAlignment(identifierLocation, *arrayType);
       }

       adjustRedeclaredBuiltInType(identifier, arrayType);

       TVariable *variable = nullptr;
       if (declareVariable(identifierLocation, identifier, arrayType, &variable))
       {
           TIntermSymbol *symbol = new TIntermSymbol(variable);
           symbol->setLine(identifierLocation);
           declarationOut->appendDeclarator(symbol);
       }
   }
}

void TParseContext::parseInitDeclarator(const TPublicType &publicType,
                                       const TSourceLoc &identifierLocation,
                                       const ImmutableString &identifier,
                                       const TSourceLoc &initLocation,
                                       TIntermTyped *initializer,
                                       TIntermDeclaration *declarationOut)
{
   // If the declaration starting this declarator list was empty (example: int,), some checks were
   // not performed.
   if (mDeferredNonEmptyDeclarationErrorCheck)
   {
       nonEmptyDeclarationErrorCheck(publicType, identifierLocation);
       mDeferredNonEmptyDeclarationErrorCheck = false;
   }

   checkDeclaratorLocationIsNotSpecified(identifierLocation, publicType);

   TIntermBinary *initNode = nullptr;
   TType *type             = new TType(publicType);
   if (executeInitializer(identifierLocation, identifier, type, initializer, &initNode))
   {
       //
       // build the intermediate representation
       //
       if (initNode)
       {
           declarationOut->appendDeclarator(initNode);
       }
   }
}

void TParseContext::parseArrayInitDeclarator(const TPublicType &elementType,
                                            const TSourceLoc &identifierLocation,
                                            const ImmutableString &identifier,
                                            const TSourceLoc &indexLocation,
                                            const TVector<unsigned int> &arraySizes,
                                            const TSourceLoc &initLocation,
                                            TIntermTyped *initializer,
                                            TIntermDeclaration *declarationOut)
{
   // If the declaration starting this declarator list was empty (example: int,), some checks were
   // not performed.
   if (mDeferredNonEmptyDeclarationErrorCheck)
   {
       nonEmptyDeclarationErrorCheck(elementType, identifierLocation);
       mDeferredNonEmptyDeclarationErrorCheck = false;
   }

   checkDeclaratorLocationIsNotSpecified(identifierLocation, elementType);

   checkIsValidTypeAndQualifierForArray(indexLocation, elementType);

   TType *arrayType = new TType(elementType);
   arrayType->makeArrays(arraySizes);

   // initNode will correspond to the whole of "b[n] = initializer".
   TIntermBinary *initNode = nullptr;
   if (executeInitializer(identifierLocation, identifier, arrayType, initializer, &initNode))
   {
       if (initNode)
       {
           declarationOut->appendDeclarator(initNode);
       }
   }
}

TIntermNode *TParseContext::addEmptyStatement(const TSourceLoc &location)
{
   // It's simpler to parse an empty statement as a constant expression rather than having a
   // different type of node just for empty statements, that will be pruned from the AST anyway.
   TIntermNode *node = CreateZeroNode(TType(EbtInt, EbpMedium));
   node->setLine(location);
   return node;
}

void TParseContext::setAtomicCounterBindingDefaultOffset(const TPublicType &publicType,
                                                        const TSourceLoc &location)
{
   const TLayoutQualifier &layoutQualifier = publicType.layoutQualifier;
   checkAtomicCounterBindingIsValid(location, layoutQualifier.binding);
   if (layoutQualifier.binding == -1 || layoutQualifier.offset == -1)
   {
       error(location, "Requires both binding and offset", "layout");
       return;
   }
   mAtomicCounterBindingStates[layoutQualifier.binding].setDefaultOffset(layoutQualifier.offset);
}

void TParseContext::parseDefaultPrecisionQualifier(const TPrecision precision,
                                                  const TPublicType &type,
                                                  const TSourceLoc &loc)
{
   if ((precision == EbpHigh) && (getShaderType() == GL_FRAGMENT_SHADER) &&
       !getFragmentPrecisionHigh())
   {
       error(loc, "precision is not supported in fragment shader", "highp");
   }

   if (!CanSetDefaultPrecisionOnType(type))
   {
       error(loc, "illegal type argument for default precision qualifier",
             getBasicString(type.getBasicType()));
       return;
   }
   symbolTable.setDefaultPrecision(type.getBasicType(), precision);
}

bool TParseContext::checkPrimitiveTypeMatchesTypeQualifier(const TTypeQualifier &typeQualifier)
{
   switch (typeQualifier.layoutQualifier.primitiveType)
   {
       case EptLines:
       case EptLinesAdjacency:
       case EptTriangles:
       case EptTrianglesAdjacency:
           return typeQualifier.qualifier == EvqGeometryIn;

       case EptLineStrip:
       case EptTriangleStrip:
           return typeQualifier.qualifier == EvqGeometryOut;

       case EptPoints:
           return true;

       default:
           UNREACHABLE();
           return false;
   }
}

void TParseContext::setGeometryShaderInputArraySize(unsigned int inputArraySize,
                                                   const TSourceLoc &line)
{
   if (!symbolTable.setGlInArraySize(inputArraySize))
   {
       error(line,
             "Array size or input primitive declaration doesn't match the size of earlier sized "
             "array inputs.",
             "layout");
   }
   mGeometryInputArraySize = inputArraySize;
}

bool TParseContext::parseGeometryShaderInputLayoutQualifier(const TTypeQualifier &typeQualifier)
{
   ASSERT(typeQualifier.qualifier == EvqGeometryIn);

   const TLayoutQualifier &layoutQualifier = typeQualifier.layoutQualifier;

   if (layoutQualifier.maxVertices != -1)
   {
       error(typeQualifier.line,
             "max_vertices can only be declared in 'out' layout in a geometry shader", "layout");
       return false;
   }

   // Set mGeometryInputPrimitiveType if exists
   if (layoutQualifier.primitiveType != EptUndefined)
   {
       if (!checkPrimitiveTypeMatchesTypeQualifier(typeQualifier))
       {
           error(typeQualifier.line, "invalid primitive type for 'in' layout", "layout");
           return false;
       }

       if (mGeometryShaderInputPrimitiveType == EptUndefined)
       {
           mGeometryShaderInputPrimitiveType = layoutQualifier.primitiveType;
           setGeometryShaderInputArraySize(
               GetGeometryShaderInputArraySize(mGeometryShaderInputPrimitiveType),
               typeQualifier.line);
       }
       else if (mGeometryShaderInputPrimitiveType != layoutQualifier.primitiveType)
       {
           error(typeQualifier.line, "primitive doesn't match earlier input primitive declaration",
                 "layout");
           return false;
       }

       // Size any implicitly sized arrays that have already been declared.
       for (TType *type : mDeferredArrayTypesToSize)
       {
           type->sizeOutermostUnsizedArray(
               symbolTable.getGlInVariableWithArraySize()->getType().getOutermostArraySize());
       }
       mDeferredArrayTypesToSize.clear();
   }

   // Set mGeometryInvocations if exists
   if (layoutQualifier.invocations > 0)
   {
       if (mGeometryShaderInvocations == 0)
       {
           mGeometryShaderInvocations = layoutQualifier.invocations;
       }
       else if (mGeometryShaderInvocations != layoutQualifier.invocations)
       {
           error(typeQualifier.line, "invocations contradicts to the earlier declaration",
                 "layout");
           return false;
       }
   }

   return true;
}

bool TParseContext::parseGeometryShaderOutputLayoutQualifier(const TTypeQualifier &typeQualifier)
{
   ASSERT(typeQualifier.qualifier == EvqGeometryOut);

   const TLayoutQualifier &layoutQualifier = typeQualifier.layoutQualifier;

   if (layoutQualifier.invocations > 0)
   {
       error(typeQualifier.line,
             "invocations can only be declared in 'in' layout in a geometry shader", "layout");
       return false;
   }

   // Set mGeometryOutputPrimitiveType if exists
   if (layoutQualifier.primitiveType != EptUndefined)
   {
       if (!checkPrimitiveTypeMatchesTypeQualifier(typeQualifier))
       {
           error(typeQualifier.line, "invalid primitive type for 'out' layout", "layout");
           return false;
       }

       if (mGeometryShaderOutputPrimitiveType == EptUndefined)
       {
           mGeometryShaderOutputPrimitiveType = layoutQualifier.primitiveType;
       }
       else if (mGeometryShaderOutputPrimitiveType != layoutQualifier.primitiveType)
       {
           error(typeQualifier.line,
                 "primitive doesn't match earlier output primitive declaration", "layout");
           return false;
       }
   }

   // Set mGeometryMaxVertices if exists
   if (layoutQualifier.maxVertices > -1)
   {
       if (mGeometryShaderMaxVertices == -1)
       {
           mGeometryShaderMaxVertices = layoutQualifier.maxVertices;
       }
       else if (mGeometryShaderMaxVertices != layoutQualifier.maxVertices)
       {
           error(typeQualifier.line, "max_vertices contradicts to the earlier declaration",
                 "layout");
           return false;
       }
   }

   return true;
}

bool TParseContext::parseTessControlShaderOutputLayoutQualifier(const TTypeQualifier &typeQualifier)
{
   ASSERT(typeQualifier.qualifier == EvqTessControlOut);

   const TLayoutQualifier &layoutQualifier = typeQualifier.layoutQualifier;

   if (layoutQualifier.vertices == 0)
   {
       error(typeQualifier.line, "No vertices specified", "layout");
       return false;
   }

   // Set mTessControlShaderOutputVertices if exists
   if (mTessControlShaderOutputVertices == 0)
   {
       mTessControlShaderOutputVertices = layoutQualifier.vertices;

       // Size any implicitly sized arrays that have already been declared.
       for (TType *type : mDeferredArrayTypesToSize)
       {
           type->sizeOutermostUnsizedArray(mTessControlShaderOutputVertices);
       }
       mDeferredArrayTypesToSize.clear();
   }
   else
   {
       error(typeQualifier.line, "Duplicated vertices specified", "layout");
   }
   return true;
}

bool TParseContext::parseTessEvaluationShaderInputLayoutQualifier(
   const TTypeQualifier &typeQualifier)
{
   ASSERT(typeQualifier.qualifier == EvqTessEvaluationIn);

   const TLayoutQualifier &layoutQualifier = typeQualifier.layoutQualifier;

   // Set mTessEvaluationShaderInputPrimitiveType if exists
   if (layoutQualifier.tesPrimitiveType != EtetUndefined)
   {
       if (mTessEvaluationShaderInputPrimitiveType == EtetUndefined)
       {
           mTessEvaluationShaderInputPrimitiveType = layoutQualifier.tesPrimitiveType;
       }
       else
       {
           error(typeQualifier.line, "Duplicated primitive type declaration", "layout");
       }
   }
   // Set mTessEvaluationShaderVertexSpacingType if exists
   if (layoutQualifier.tesVertexSpacingType != EtetUndefined)
   {
       if (mTessEvaluationShaderInputVertexSpacingType == EtetUndefined)
       {
           mTessEvaluationShaderInputVertexSpacingType = layoutQualifier.tesVertexSpacingType;
       }
       else
       {
           error(typeQualifier.line, "Duplicated vertex spacing declaration", "layout");
       }
   }
   // Set mTessEvaluationShaderInputOrderingType if exists
   if (layoutQualifier.tesOrderingType != EtetUndefined)
   {
       if (mTessEvaluationShaderInputOrderingType == EtetUndefined)
       {
           mTessEvaluationShaderInputOrderingType = layoutQualifier.tesOrderingType;
       }
       else
       {
           error(typeQualifier.line, "Duplicated ordering declaration", "layout");
       }
   }
   // Set mTessEvaluationShaderInputPointType if exists
   if (layoutQualifier.tesPointType != EtetUndefined)
   {
       if (mTessEvaluationShaderInputPointType == EtetUndefined)
       {
           mTessEvaluationShaderInputPointType = layoutQualifier.tesPointType;
       }
       else
       {
           error(typeQualifier.line, "Duplicated point type declaration", "layout");
       }
   }

   return true;
}

void TParseContext::parseGlobalLayoutQualifier(const TTypeQualifierBuilder &typeQualifierBuilder)
{
   TTypeQualifier typeQualifier = typeQualifierBuilder.getVariableTypeQualifier(mDiagnostics);
   const TLayoutQualifier layoutQualifier = typeQualifier.layoutQualifier;

   checkInvariantVariableQualifier(typeQualifier.invariant, typeQualifier.qualifier,
                                   typeQualifier.line);

   // It should never be the case, but some strange parser errors can send us here.
   if (layoutQualifier.isEmpty())
   {
       error(typeQualifier.line, "Error during layout qualifier parsing.", "?");
       return;
   }

   if (!layoutQualifier.isCombinationValid())
   {
       error(typeQualifier.line, "invalid layout qualifier combination", "layout");
       return;
   }

   checkIndexIsNotSpecified(typeQualifier.line, layoutQualifier.index);

   checkBindingIsNotSpecified(typeQualifier.line, layoutQualifier.binding);

   checkMemoryQualifierIsNotSpecified(typeQualifier.memoryQualifier, typeQualifier.line);

   checkInternalFormatIsNotSpecified(typeQualifier.line, layoutQualifier.imageInternalFormat);

   checkYuvIsNotSpecified(typeQualifier.line, layoutQualifier.yuv);

   checkOffsetIsNotSpecified(typeQualifier.line, layoutQualifier.offset);

   checkStd430IsForShaderStorageBlock(typeQualifier.line, layoutQualifier.blockStorage,
                                      typeQualifier.qualifier);

   checkAdvancedBlendEquationsNotSpecified(
       typeQualifier.line, layoutQualifier.advancedBlendEquations, typeQualifier.qualifier);

   if (typeQualifier.qualifier != EvqFragmentIn)
   {
       checkEarlyFragmentTestsIsNotSpecified(typeQualifier.line,
                                             layoutQualifier.earlyFragmentTests);
   }

   if (typeQualifier.qualifier == EvqComputeIn)
   {
       if (mComputeShaderLocalSizeDeclared &&
           !layoutQualifier.isLocalSizeEqual(mComputeShaderLocalSize))
       {
           error(typeQualifier.line, "Work group size does not match the previous declaration",
                 "layout");
           return;
       }

       if (mShaderVersion < 310)
       {
           error(typeQualifier.line, "in type qualifier supported in GLSL ES 3.10 only", "layout");
           return;
       }

       if (!layoutQualifier.localSize.isAnyValueSet())
       {
           error(typeQualifier.line, "No local work group size specified", "layout");
           return;
       }

       const TVariable *maxComputeWorkGroupSize = static_cast<const TVariable *>(
           symbolTable.findBuiltIn(ImmutableString("gl_MaxComputeWorkGroupSize"), mShaderVersion));

       const TConstantUnion *maxComputeWorkGroupSizeData =
           maxComputeWorkGroupSize->getConstPointer();

       for (size_t i = 0u; i < layoutQualifier.localSize.size(); ++i)
       {
           if (layoutQualifier.localSize[i] != -1)
           {
               mComputeShaderLocalSize[i]             = layoutQualifier.localSize[i];
               const int maxComputeWorkGroupSizeValue = maxComputeWorkGroupSizeData[i].getIConst();
               if (mComputeShaderLocalSize[i] < 1 ||
                   mComputeShaderLocalSize[i] > maxComputeWorkGroupSizeValue)
               {
                   std::stringstream reasonStream = sh::InitializeStream<std::stringstream>();
                   reasonStream << "invalid value: Value must be at least 1 and no greater than "
                                << maxComputeWorkGroupSizeValue;
                   const std::string &reason = reasonStream.str();

                   error(typeQualifier.line, reason.c_str(), getWorkGroupSizeString(i));
                   return;
               }
           }
       }

       mComputeShaderLocalSizeDeclared = true;
   }
   else if (typeQualifier.qualifier == EvqGeometryIn)
   {
       if (mShaderVersion < 310)
       {
           error(typeQualifier.line, "in type qualifier supported in GLSL ES 3.10 only", "layout");
           return;
       }

       if (!parseGeometryShaderInputLayoutQualifier(typeQualifier))
       {
           return;
       }
   }
   else if (typeQualifier.qualifier == EvqGeometryOut)
   {
       if (mShaderVersion < 310)
       {
           error(typeQualifier.line, "out type qualifier supported in GLSL ES 3.10 only",
                 "layout");
           return;
       }

       if (!parseGeometryShaderOutputLayoutQualifier(typeQualifier))
       {
           return;
       }
   }
   else if (anyMultiviewExtensionAvailable() && typeQualifier.qualifier == EvqVertexIn)
   {
       // This error is only specified in WebGL, but tightens unspecified behavior in the native
       // specification.
       if (mNumViews != -1 && layoutQualifier.numViews != mNumViews)
       {
           error(typeQualifier.line, "Number of views does not match the previous declaration",
                 "layout");
           return;
       }

       if (layoutQualifier.numViews == -1)
       {
           error(typeQualifier.line, "No num_views specified", "layout");
           return;
       }

       if (layoutQualifier.numViews > mMaxNumViews)
       {
           error(typeQualifier.line, "num_views greater than the value of GL_MAX_VIEWS_OVR",
                 "layout");
           return;
       }

       mNumViews = layoutQualifier.numViews;
   }
   else if (typeQualifier.qualifier == EvqFragmentIn)
   {
       if (mShaderVersion < 310)
       {
           error(typeQualifier.line,
                 "in type qualifier without variable declaration supported in GLSL ES 3.10 and "
                 "after",
                 "layout");
           return;
       }

       if (!layoutQualifier.earlyFragmentTests)
       {
           error(typeQualifier.line,
                 "only early_fragment_tests is allowed as layout qualifier when not declaring a "
                 "variable",
                 "layout");
           return;
       }

       mEarlyFragmentTestsSpecified = true;
   }
   else if (typeQualifier.qualifier == EvqFragmentOut)
   {
       if (mShaderVersion < 320 && !isExtensionEnabled(TExtension::KHR_blend_equation_advanced))
       {
           error(typeQualifier.line,
                 "out type qualifier without variable declaration is supported in GLSL ES 3.20,"
                 " or if GL_KHR_blend_equation_advanced is enabled",
                 "layout");
           return;
       }

       if (!layoutQualifier.advancedBlendEquations.any())
       {
           error(typeQualifier.line,
                 "only blend equations are allowed as layout qualifier when not declaring a "
                 "variable",
                 "layout");
           return;
       }

       mAdvancedBlendEquations |= layoutQualifier.advancedBlendEquations;
   }
   else if (typeQualifier.qualifier == EvqTessControlOut)
   {
       if (mShaderVersion < 310)
       {
           error(typeQualifier.line, "out type qualifier supported in GLSL ES 3.10 and after",
                 "layout");
           return;
       }

       if (!parseTessControlShaderOutputLayoutQualifier(typeQualifier))
       {
           return;
       }
   }
   else if (typeQualifier.qualifier == EvqTessEvaluationIn)
   {
       if (mShaderVersion < 310)
       {
           error(typeQualifier.line, "in type qualifier supported in GLSL ES 3.10 and after",
                 "layout");
           return;
       }

       if (!parseTessEvaluationShaderInputLayoutQualifier(typeQualifier))
       {
           return;
       }
   }
   else
   {
       if (!checkWorkGroupSizeIsNotSpecified(typeQualifier.line, layoutQualifier))
       {
           return;
       }

       if (typeQualifier.qualifier != EvqUniform && typeQualifier.qualifier != EvqBuffer)
       {
           error(typeQualifier.line, "invalid qualifier: global layout can only be set for blocks",
                 getQualifierString(typeQualifier.qualifier));
           return;
       }

       if (mShaderVersion < 300)
       {
           error(typeQualifier.line, "layout qualifiers supported in GLSL ES 3.00 and after",
                 "layout");
           return;
       }

       checkLocationIsNotSpecified(typeQualifier.line, layoutQualifier);

       if (layoutQualifier.matrixPacking != EmpUnspecified)
       {
           if (typeQualifier.qualifier == EvqUniform)
           {
               mDefaultUniformMatrixPacking = layoutQualifier.matrixPacking;
           }
           else if (typeQualifier.qualifier == EvqBuffer)
           {
               mDefaultBufferMatrixPacking = layoutQualifier.matrixPacking;
           }
       }

       if (layoutQualifier.blockStorage != EbsUnspecified)
       {
           if (typeQualifier.qualifier == EvqUniform)
           {
               mDefaultUniformBlockStorage = layoutQualifier.blockStorage;
           }
           else if (typeQualifier.qualifier == EvqBuffer)
           {
               mDefaultBufferBlockStorage = layoutQualifier.blockStorage;
           }
       }
   }
}

TIntermFunctionPrototype *TParseContext::createPrototypeNodeFromFunction(
   const TFunction &function,
   const TSourceLoc &location,
   bool insertParametersToSymbolTable)
{
   checkIsNotReserved(location, function.name());

   TIntermFunctionPrototype *prototype = new TIntermFunctionPrototype(&function);
   prototype->setLine(location);

   for (size_t i = 0; i < function.getParamCount(); i++)
   {
       const TVariable *param = function.getParam(i);

       // If the parameter has no name, it's not an error, just don't add it to symbol table (could
       // be used for unused args).
       if (param->symbolType() != SymbolType::Empty)
       {
           if (insertParametersToSymbolTable)
           {
               if (!symbolTable.declare(const_cast<TVariable *>(param)))
               {
                   error(location, "redefinition", param->name());
               }
           }
           // Unsized type of a named parameter should have already been checked and sanitized.
           ASSERT(!param->getType().isUnsizedArray());
       }
       else
       {
           if (param->getType().isUnsizedArray())
           {
               error(location, "function parameter array must be sized at compile time", "[]");
               // We don't need to size the arrays since the parameter is unnamed and hence
               // inaccessible.
           }
       }
   }
   return prototype;
}

TIntermFunctionPrototype *TParseContext::addFunctionPrototypeDeclaration(
   const TFunction &parsedFunction,
   const TSourceLoc &location)
{
   // Note: function found from the symbol table could be the same as parsedFunction if this is the
   // first declaration. Either way the instance in the symbol table is used to track whether the
   // function is declared multiple times.
   bool hadPrototypeDeclaration = false;
   const TFunction *function    = symbolTable.markFunctionHasPrototypeDeclaration(
          parsedFunction.getMangledName(), &hadPrototypeDeclaration);

   if (hadPrototypeDeclaration && mShaderVersion == 100)
   {
       // ESSL 1.00.17 section 4.2.7.
       // Doesn't apply to ESSL 3.00.4: see section 4.2.3.
       error(location, "duplicate function prototype declarations are not allowed", "function");
   }

   TIntermFunctionPrototype *prototype =
       createPrototypeNodeFromFunction(*function, location, false);

   symbolTable.pop();

   if (!symbolTable.atGlobalLevel())
   {
       // ESSL 3.00.4 section 4.2.4.
       error(location, "local function prototype declarations are not allowed", "function");
   }

   return prototype;
}

TIntermFunctionDefinition *TParseContext::addFunctionDefinition(
   TIntermFunctionPrototype *functionPrototype,
   TIntermBlock *functionBody,
   const TSourceLoc &location)
{
   // Undo push at end of parseFunctionDefinitionHeader() below for ESSL1.00 case
   if (mFunctionBodyNewScope)
   {
       mFunctionBodyNewScope = false;
       symbolTable.pop();
   }

   // Check that non-void functions have at least one return statement.
   if (mCurrentFunctionType->getBasicType() != EbtVoid && !mFunctionReturnsValue)
   {
       error(location,
             "function does not return a value:", functionPrototype->getFunction()->name());
   }

   if (functionBody == nullptr)
   {
       functionBody = new TIntermBlock();
       functionBody->setLine(location);
   }
   TIntermFunctionDefinition *functionNode =
       new TIntermFunctionDefinition(functionPrototype, functionBody);
   functionNode->setLine(location);

   symbolTable.pop();
   return functionNode;
}

void TParseContext::parseFunctionDefinitionHeader(const TSourceLoc &location,
                                                 const TFunction *function,
                                                 TIntermFunctionPrototype **prototypeOut)
{
   ASSERT(function);

   bool wasDefined = false;
   function        = symbolTable.setFunctionParameterNamesFromDefinition(function, &wasDefined);
   if (wasDefined)
   {
       error(location, "function already has a body", function->name());
   }

   // Remember the return type for later checking for return statements.
   mCurrentFunctionType  = &(function->getReturnType());
   mFunctionReturnsValue = false;

   *prototypeOut = createPrototypeNodeFromFunction(*function, location, true);
   setLoopNestingLevel(0);

   // ESSL 1.00 spec allows for variable in function body to redefine parameter
   if (IsSpecWithFunctionBodyNewScope(mShaderSpec, mShaderVersion))
   {
       mFunctionBodyNewScope = true;
       symbolTable.push();
   }
}

TFunction *TParseContext::parseFunctionDeclarator(const TSourceLoc &location, TFunction *function)
{
   //
   // We don't know at this point whether this is a function definition or a prototype.
   // The definition production code will check for redefinitions.
   // In the case of ESSL 1.00 the prototype production code will also check for redeclarations.
   //

   for (size_t i = 0u; i < function->getParamCount(); ++i)
   {
       const TVariable *param = function->getParam(i);
       const TType &paramType = param->getType();

       if (paramType.isStructSpecifier())
       {
           // ESSL 3.00.6 section 12.10.
           error(location, "Function parameter type cannot be a structure definition",
                 function->name());
       }

       checkPrecisionSpecified(location, paramType.getPrecision(), paramType.getBasicType());
   }

   if (getShaderVersion() >= 300)
   {
       if (symbolTable.isUnmangledBuiltInName(function->name(), getShaderVersion(),
                                              extensionBehavior()))
       {
           // With ESSL 3.00 and above, names of built-in functions cannot be redeclared as
           // functions. Therefore overloading or redefining builtin functions is an error.
           error(location, "Name of a built-in function cannot be redeclared as function",
                 function->name());
       }
   }
   else
   {
       // ESSL 1.00.17 section 4.2.6: built-ins can be overloaded but not redefined. We assume that
       // this applies to redeclarations as well.
       const TSymbol *builtIn =
           symbolTable.findBuiltIn(function->getMangledName(), getShaderVersion());
       if (builtIn)
       {
           error(location, "built-in functions cannot be redefined", function->name());
       }
   }

   // Return types and parameter qualifiers must match in all redeclarations, so those are checked
   // here.
   const TFunction *prevDec =
       static_cast<const TFunction *>(symbolTable.findGlobal(function->getMangledName()));
   if (prevDec)
   {
       if (prevDec->getReturnType() != function->getReturnType())
       {
           error(location, "function must have the same return type in all of its declarations",
                 function->getReturnType().getBasicString());
       }
       for (size_t i = 0; i < prevDec->getParamCount(); ++i)
       {
           if (prevDec->getParam(i)->getType().getQualifier() !=
               function->getParam(i)->getType().getQualifier())
           {
               error(location,
                     "function must have the same parameter qualifiers in all of its declarations",
                     function->getParam(i)->getType().getQualifierString());
           }
       }
   }

   // Check for previously declared variables using the same name.
   const TSymbol *prevSym   = symbolTable.find(function->name(), getShaderVersion());
   bool insertUnmangledName = true;
   if (prevSym)
   {
       if (!prevSym->isFunction())
       {
           error(location, "redefinition of a function", function->name());
       }
       insertUnmangledName = false;
   }
   // Parsing is at the inner scope level of the function's arguments and body statement at this
   // point, but declareUserDefinedFunction takes care of declaring the function at the global
   // scope.
   symbolTable.declareUserDefinedFunction(function, insertUnmangledName);

   // Raise error message if main function takes any parameters or return anything other than void
   if (function->isMain())
   {
       if (function->getParamCount() > 0)
       {
           error(location, "function cannot take any parameter(s)", "main");
       }
       if (function->getReturnType().getBasicType() != EbtVoid)
       {
           error(location, "main function cannot return a value",
                 function->getReturnType().getBasicString());
       }
   }

   mDeclaringMain = function->isMain();

   //
   // If this is a redeclaration, it could also be a definition, in which case, we want to use the
   // variable names from this one, and not the one that's
   // being redeclared.  So, pass back up this declaration, not the one in the symbol table.
   //
   return function;
}

TFunction *TParseContext::parseFunctionHeader(const TPublicType &type,
                                             const ImmutableString &name,
                                             const TSourceLoc &location)
{
   if (type.qualifier != EvqGlobal && type.qualifier != EvqTemporary)
   {
       error(location, "no qualifiers allowed for function return",
             getQualifierString(type.qualifier));
   }
   if (!type.layoutQualifier.isEmpty())
   {
       error(location, "no qualifiers allowed for function return", "layout");
   }
   // make sure an opaque type is not involved as well...
   std::string reason(getBasicString(type.getBasicType()));
   reason += "s can't be function return values";
   checkIsNotOpaqueType(location, type.typeSpecifierNonArray, reason.c_str());
   if (mShaderVersion < 300)
   {
       // Array return values are forbidden, but there's also no valid syntax for declaring array
       // return values in ESSL 1.00.
       ASSERT(!type.isArray() || mDiagnostics->numErrors() > 0);

       if (type.isStructureContainingArrays())
       {
           // ESSL 1.00.17 section 6.1 Function Definitions
           TInfoSinkBase typeString;
           typeString << TType(type);
           error(location, "structures containing arrays can't be function return values",
                 typeString.c_str());
       }
   }

   // Add the function as a prototype after parsing it (we do not support recursion)
   return new TFunction(&symbolTable, name, SymbolType::UserDefined, new TType(type), false);
}

TFunctionLookup *TParseContext::addNonConstructorFunc(const ImmutableString &name,
                                                     const TSymbol *symbol)
{
   return TFunctionLookup::CreateFunctionCall(name, symbol);
}

TFunctionLookup *TParseContext::addConstructorFunc(const TPublicType &publicType)
{
   if (mShaderVersion < 300 && publicType.isArray())
   {
       error(publicType.getLine(), "array constructor supported in GLSL ES 3.00 and above only",
             "[]");
   }
   if (publicType.isStructSpecifier())
   {
       error(publicType.getLine(), "constructor can't be a structure definition",
             getBasicString(publicType.getBasicType()));
   }

   TType *type = new TType(publicType);
   if (!type->canBeConstructed())
   {
       error(publicType.getLine(), "cannot construct this type",
             getBasicString(publicType.getBasicType()));
       type->setBasicType(EbtFloat);
   }
   return TFunctionLookup::CreateConstructor(type);
}

void TParseContext::checkIsNotUnsizedArray(const TSourceLoc &line,
                                          const char *errorMessage,
                                          const ImmutableString &token,
                                          TType *arrayType)
{
   if (arrayType->isUnsizedArray())
   {
       error(line, errorMessage, token);
       arrayType->sizeUnsizedArrays(TSpan<const unsigned int>());
   }
}

TParameter TParseContext::parseParameterDeclarator(TType *type,
                                                  const ImmutableString &name,
                                                  const TSourceLoc &nameLoc)
{
   ASSERT(type);
   checkIsNotUnsizedArray(nameLoc, "function parameter array must specify a size", name, type);
   if (type->getBasicType() == EbtVoid)
   {
       error(nameLoc, "illegal use of type 'void'", name);
   }
   checkIsNotReserved(nameLoc, name);
   TParameter param = {name.data(), type};
   return param;
}

TParameter TParseContext::parseParameterDeclarator(const TPublicType &publicType,
                                                  const ImmutableString &name,
                                                  const TSourceLoc &nameLoc)
{
   TType *type = new TType(publicType);
   return parseParameterDeclarator(type, name, nameLoc);
}

TParameter TParseContext::parseParameterArrayDeclarator(const ImmutableString &name,
                                                       const TSourceLoc &nameLoc,
                                                       const TVector<unsigned int> &arraySizes,
                                                       const TSourceLoc &arrayLoc,
                                                       TPublicType *elementType)
{
   checkArrayElementIsNotArray(arrayLoc, *elementType);
   TType *arrayType = new TType(*elementType);
   arrayType->makeArrays(arraySizes);
   return parseParameterDeclarator(arrayType, name, nameLoc);
}

bool TParseContext::checkUnsizedArrayConstructorArgumentDimensionality(
   const TIntermSequence &arguments,
   TType type,
   const TSourceLoc &line)
{
   if (arguments.empty())
   {
       error(line, "implicitly sized array constructor must have at least one argument", "[]");
       return false;
   }
   for (TIntermNode *arg : arguments)
   {
       const TIntermTyped *element = arg->getAsTyped();
       ASSERT(element);
       size_t dimensionalityFromElement = element->getType().getNumArraySizes() + 1u;
       if (dimensionalityFromElement > type.getNumArraySizes())
       {
           error(line, "constructing from a non-dereferenced array", "constructor");
           return false;
       }
       else if (dimensionalityFromElement < type.getNumArraySizes())
       {
           if (dimensionalityFromElement == 1u)
           {
               error(line, "implicitly sized array of arrays constructor argument is not an array",
                     "constructor");
           }
           else
           {
               error(line,
                     "implicitly sized array of arrays constructor argument dimensionality is too "
                     "low",
                     "constructor");
           }
           return false;
       }
   }
   return true;
}

// This function is used to test for the correctness of the parameters passed to various constructor
// functions and also convert them to the right datatype if it is allowed and required.
//
// Returns a node to add to the tree regardless of if an error was generated or not.
//
TIntermTyped *TParseContext::addConstructor(TFunctionLookup *fnCall, const TSourceLoc &line)
{
   TType type                 = fnCall->constructorType();
   TIntermSequence &arguments = fnCall->arguments();
   if (type.isUnsizedArray())
   {
       if (!checkUnsizedArrayConstructorArgumentDimensionality(arguments, type, line))
       {
           type.sizeUnsizedArrays(TSpan<const unsigned int>());
           return CreateZeroNode(type);
       }
       TIntermTyped *firstElement = arguments.at(0)->getAsTyped();
       ASSERT(firstElement);
       if (type.getOutermostArraySize() == 0u)
       {
           type.sizeOutermostUnsizedArray(static_cast<unsigned int>(arguments.size()));
       }
       for (size_t i = 0; i < firstElement->getType().getNumArraySizes(); ++i)
       {
           if (type.getArraySizes()[i] == 0u)
           {
               type.setArraySize(i, firstElement->getType().getArraySizes()[i]);
           }
       }
       ASSERT(!type.isUnsizedArray());
   }

   if (!checkConstructorArguments(line, arguments, type))
   {
       return CreateZeroNode(type);
   }

   TIntermAggregate *constructorNode = TIntermAggregate::CreateConstructor(type, &arguments);
   constructorNode->setLine(line);

   return constructorNode->fold(mDiagnostics);
}

//
// Interface/uniform blocks
TIntermDeclaration *TParseContext::addInterfaceBlock(
   const TTypeQualifierBuilder &typeQualifierBuilder,
   const TSourceLoc &nameLine,
   const ImmutableString &blockName,
   TFieldList *fieldList,
   const ImmutableString &instanceName,
   const TSourceLoc &instanceLine,
   const TVector<unsigned int> *arraySizes,
   const TSourceLoc &arraySizesLine)
{
   const bool isGLPerVertex = blockName == "gl_PerVertex";
   // gl_PerVertex is allowed to be redefined and therefore not reserved
   if (!isGLPerVertex)
   {
       checkIsNotReserved(nameLine, blockName);
   }

   TTypeQualifier typeQualifier = typeQualifierBuilder.getVariableTypeQualifier(mDiagnostics);

   const bool isUniformOrBuffer =
       typeQualifier.qualifier == EvqUniform || typeQualifier.qualifier == EvqBuffer;
   const bool isShaderIoBlock = IsShaderIoBlock(typeQualifier.qualifier);

   if (mShaderVersion < 310 && typeQualifier.qualifier != EvqUniform)
   {
       error(typeQualifier.line,
             "invalid qualifier: interface blocks must be uniform in version lower than GLSL ES "
             "3.10",
             getQualifierString(typeQualifier.qualifier));
   }
   else if (typeQualifier.qualifier == EvqPatchOut)
   {
       if ((!isExtensionEnabled(TExtension::EXT_tessellation_shader) && mShaderVersion < 320) ||
           mShaderType != GL_TESS_CONTROL_SHADER)
       {
           error(typeQualifier.line,
                 "invalid qualifier: 'patch out' requires a tessellation control shader",
                 getQualifierString(typeQualifier.qualifier));
       }
   }
   else if (typeQualifier.qualifier == EvqPatchIn)
   {
       if ((!isExtensionEnabled(TExtension::EXT_tessellation_shader) && mShaderVersion < 320) ||
           mShaderType != GL_TESS_EVALUATION_SHADER)
       {
           error(typeQualifier.line,
                 "invalid qualifier: 'patch in' requires a tessellation evaluation shader",
                 getQualifierString(typeQualifier.qualifier));
       }
   }
   else if (typeQualifier.qualifier != EvqUniform && typeQualifier.qualifier != EvqBuffer)
   {
       if (isShaderIoBlock)
       {
           if (!isExtensionEnabled(TExtension::OES_shader_io_blocks) &&
               !isExtensionEnabled(TExtension::EXT_shader_io_blocks) &&
               !isExtensionEnabled(TExtension::OES_geometry_shader) &&
               !isExtensionEnabled(TExtension::EXT_geometry_shader) && mShaderVersion < 320)
           {
               error(typeQualifier.line,
                     "invalid qualifier: shader IO blocks need shader io block extension",
                     getQualifierString(typeQualifier.qualifier));
           }

           // Both inputs and outputs of tessellation control shaders must be arrays.
           // For tessellation evaluation shaders, only inputs must necessarily be arrays.
           const bool isTCS = mShaderType == GL_TESS_CONTROL_SHADER;
           const bool isTESIn =
               mShaderType == GL_TESS_EVALUATION_SHADER && IsShaderIn(typeQualifier.qualifier);
           if (arraySizes == nullptr && (isTCS || isTESIn))
           {
               error(typeQualifier.line, "type must be an array", blockName);
           }
       }
       else
       {
           error(typeQualifier.line,
                 "invalid qualifier: interface blocks must be uniform or buffer",
                 getQualifierString(typeQualifier.qualifier));
       }
   }

   if (typeQualifier.invariant)
   {
       error(typeQualifier.line, "invalid qualifier on interface block", "invariant");
   }

   if (typeQualifier.qualifier != EvqBuffer)
   {
       checkMemoryQualifierIsNotSpecified(typeQualifier.memoryQualifier, typeQualifier.line);
   }

   // Verify array sizes
   if (arraySizes)
   {
       if (isUniformOrBuffer)
       {
           if (arraySizes->size() == 0)
           {
               error(arraySizesLine, "unsized arrays are not allowed with interface blocks", "");
           }
           if (arraySizes->size() > 1)
           {
               error(arraySizesLine, "array of arrays are not allowed with interface blocks", "");
           }
       }
       else if (isShaderIoBlock)
       {
           size_t arrayDimensions = arraySizes->size();

           // Geometry shader inputs have a level arrayness that must be ignored.
           if (mShaderType == GL_GEOMETRY_SHADER_EXT && IsVaryingIn(typeQualifier.qualifier))
           {
               ASSERT(arrayDimensions > 0);
               --arrayDimensions;

               // Validate that the array size of input matches the geometry layout
               // declaration, if not automatic (specified as []).
               const unsigned int geometryDim = arraySizes->back();
               if (geometryDim > 0 && geometryDim != mGeometryInputArraySize)
               {
                   error(arraySizesLine,
                         "geometry shader input block array size inconsistent "
                         "with primitive",
                         "");
               }
           }

           if (arrayDimensions > 1)
           {
               error(arraySizesLine, "array of arrays are not allowed with I/O blocks", "");
           }
       }
   }
   else if (isShaderIoBlock && mShaderType == GL_GEOMETRY_SHADER_EXT &&
            IsVaryingIn(typeQualifier.qualifier))
   {
       error(arraySizesLine, "geometry shader input blocks must be an array", "");
   }

   checkIndexIsNotSpecified(typeQualifier.line, typeQualifier.layoutQualifier.index);

   if (mShaderVersion < 310)
   {
       checkBindingIsNotSpecified(typeQualifier.line, typeQualifier.layoutQualifier.binding);
   }
   else
   {
       unsigned int arraySize =
           arraySizes == nullptr || arraySizes->empty() ? 0 : (*arraySizes)[0];
       checkBlockBindingIsValid(typeQualifier.line, typeQualifier.qualifier,
                                typeQualifier.layoutQualifier.binding, arraySize);
   }

   checkYuvIsNotSpecified(typeQualifier.line, typeQualifier.layoutQualifier.yuv);
   checkEarlyFragmentTestsIsNotSpecified(typeQualifier.line,
                                         typeQualifier.layoutQualifier.earlyFragmentTests);
   checkNoncoherentIsNotSpecified(typeQualifier.line, typeQualifier.layoutQualifier.noncoherent);

   TLayoutQualifier blockLayoutQualifier = typeQualifier.layoutQualifier;
   if (!IsShaderIoBlock(typeQualifier.qualifier) && typeQualifier.qualifier != EvqPatchIn &&
       typeQualifier.qualifier != EvqPatchOut)
   {
       checkLocationIsNotSpecified(typeQualifier.line, blockLayoutQualifier);
   }
   checkStd430IsForShaderStorageBlock(typeQualifier.line, blockLayoutQualifier.blockStorage,
                                      typeQualifier.qualifier);

   if (blockLayoutQualifier.matrixPacking == EmpUnspecified)
   {
       if (typeQualifier.qualifier == EvqUniform)
       {
           blockLayoutQualifier.matrixPacking = mDefaultUniformMatrixPacking;
       }
       else if (typeQualifier.qualifier == EvqBuffer)
       {
           blockLayoutQualifier.matrixPacking = mDefaultBufferMatrixPacking;
       }
   }

   if (blockLayoutQualifier.blockStorage == EbsUnspecified)
   {
       if (typeQualifier.qualifier == EvqUniform)
       {
           blockLayoutQualifier.blockStorage = mDefaultUniformBlockStorage;
       }
       else if (typeQualifier.qualifier == EvqBuffer)
       {
           blockLayoutQualifier.blockStorage = mDefaultBufferBlockStorage;
       }
   }

   checkWorkGroupSizeIsNotSpecified(nameLine, blockLayoutQualifier);

   checkInternalFormatIsNotSpecified(nameLine, blockLayoutQualifier.imageInternalFormat);

   // check for sampler types and apply layout qualifiers
   for (size_t memberIndex = 0; memberIndex < fieldList->size(); ++memberIndex)
   {
       TField *field    = (*fieldList)[memberIndex];
       TType *fieldType = field->type();
       if (IsOpaqueType(fieldType->getBasicType()))
       {
           std::string reason("unsupported type - ");
           reason += fieldType->getBasicString();
           reason += " types are not allowed in interface blocks";
           error(field->line(), reason.c_str(), fieldType->getBasicString());
       }

       const TQualifier qualifier = fieldType->getQualifier();
       switch (qualifier)
       {
           case EvqGlobal:
               break;
           case EvqUniform:
               if (typeQualifier.qualifier == EvqBuffer)
               {
                   error(field->line(), "invalid qualifier on shader storage block member",
                         getQualifierString(qualifier));
               }
               break;
           case EvqBuffer:
               if (typeQualifier.qualifier == EvqUniform)
               {
                   error(field->line(), "invalid qualifier on uniform block member",
                         getQualifierString(qualifier));
               }
               break;
           // a member variable in io block may have different interpolation.
           case EvqFlatIn:
           case EvqFlatOut:
           case EvqNoPerspectiveIn:
           case EvqNoPerspectiveOut:
           case EvqSmoothIn:
           case EvqSmoothOut:
           case EvqCentroidIn:
           case EvqCentroidOut:
               break;
           // a member variable can have an incomplete qualifier because shader io block has either
           // in or out.
           case EvqSmooth:
           case EvqFlat:
           case EvqNoPerspective:
           case EvqCentroid:
           case EvqGeometryIn:
           case EvqGeometryOut:
               if (!IsShaderIoBlock(typeQualifier.qualifier) &&
                   typeQualifier.qualifier != EvqPatchIn &&
                   typeQualifier.qualifier != EvqPatchOut &&
                   typeQualifier.qualifier != EvqGeometryIn &&
                   typeQualifier.qualifier != EvqGeometryOut)
               {
                   error(field->line(), "invalid qualifier on interface block member",
                         getQualifierString(qualifier));
               }
               break;
           default:
               error(field->line(), "invalid qualifier on interface block member",
                     getQualifierString(qualifier));
               break;
       }

       // On interface block members, invariant is only applicable to output I/O blocks.
       const bool isOutputShaderIoBlock = isShaderIoBlock && IsShaderOut(typeQualifier.qualifier);
       if (fieldType->isInvariant() && !isOutputShaderIoBlock)
       {
           error(field->line(), "invalid qualifier on interface block member", "invariant");
       }

       // check layout qualifiers
       TLayoutQualifier fieldLayoutQualifier = fieldType->getLayoutQualifier();
       checkIndexIsNotSpecified(field->line(), fieldLayoutQualifier.index);
       checkBindingIsNotSpecified(field->line(), fieldLayoutQualifier.binding);

       if (fieldLayoutQualifier.blockStorage != EbsUnspecified)
       {
           error(field->line(), "invalid layout qualifier: cannot be used here",
                 getBlockStorageString(fieldLayoutQualifier.blockStorage));
       }

       if (fieldLayoutQualifier.matrixPacking == EmpUnspecified)
       {
           fieldLayoutQualifier.matrixPacking = blockLayoutQualifier.matrixPacking;
       }
       else if (!fieldType->isMatrix() && fieldType->getBasicType() != EbtStruct)
       {
           warning(field->line(),
                   "extraneous layout qualifier: only has an effect on matrix types",
                   getMatrixPackingString(fieldLayoutQualifier.matrixPacking));
       }

       fieldType->setLayoutQualifier(fieldLayoutQualifier);

       if (mShaderVersion < 310 || memberIndex != fieldList->size() - 1u ||
           typeQualifier.qualifier != EvqBuffer)
       {
           // ESSL 3.10 spec section 4.1.9 allows for runtime-sized arrays.
           checkIsNotUnsizedArray(field->line(),
                                  "array members of interface blocks must specify a size",
                                  field->name(), field->type());
       }

       if (typeQualifier.qualifier == EvqBuffer)
       {
           // set memory qualifiers
           // GLSL ES 3.10 session 4.9 [Memory Access Qualifiers]. When a block declaration is
           // qualified with a memory qualifier, it is as if all of its members were declared with
           // the same memory qualifier.
           const TMemoryQualifier &blockMemoryQualifier = typeQualifier.memoryQualifier;
           TMemoryQualifier fieldMemoryQualifier        = fieldType->getMemoryQualifier();
           fieldMemoryQualifier.readonly |= blockMemoryQualifier.readonly;
           fieldMemoryQualifier.writeonly |= blockMemoryQualifier.writeonly;
           fieldMemoryQualifier.coherent |= blockMemoryQualifier.coherent;
           fieldMemoryQualifier.restrictQualifier |= blockMemoryQualifier.restrictQualifier;
           fieldMemoryQualifier.volatileQualifier |= blockMemoryQualifier.volatileQualifier;
           // TODO(jiajia.qin@intel.com): Decide whether if readonly and writeonly buffer variable
           // is legal. See bug https://github.com/KhronosGroup/OpenGL-API/issues/7
           fieldType->setMemoryQualifier(fieldMemoryQualifier);
       }
   }

   SymbolType instanceSymbolType = SymbolType::UserDefined;
   if (isGLPerVertex)
   {
       instanceSymbolType = SymbolType::BuiltIn;
   }
   TInterfaceBlock *interfaceBlock = new TInterfaceBlock(&symbolTable, blockName, fieldList,
                                                         blockLayoutQualifier, instanceSymbolType);
   if (!symbolTable.declare(interfaceBlock) && isUniformOrBuffer)
   {
       error(nameLine, "redefinition of an interface block name", blockName);
   }

   TType *interfaceBlockType =
       new TType(interfaceBlock, typeQualifier.qualifier, blockLayoutQualifier);
   if (arraySizes)
   {
       interfaceBlockType->makeArrays(*arraySizes);

       checkGeometryShaderInputAndSetArraySize(instanceLine, instanceName, interfaceBlockType);
       checkTessellationShaderUnsizedArraysAndSetSize(instanceLine, instanceName,
                                                      interfaceBlockType);
   }

   // The instance variable gets created to refer to the interface block type from the AST
   // regardless of if there's an instance name. It's created as an empty symbol if there is no
   // instance name.
   TVariable *instanceVariable =
       new TVariable(&symbolTable, instanceName, interfaceBlockType,
                     instanceName.empty() ? SymbolType::Empty : SymbolType::UserDefined);

   if (instanceVariable->symbolType() == SymbolType::Empty)
   {
       // define symbols for the members of the interface block
       for (size_t memberIndex = 0; memberIndex < fieldList->size(); ++memberIndex)
       {
           TField *field    = (*fieldList)[memberIndex];
           TType *fieldType = new TType(*field->type());

           // set parent pointer of the field variable
           fieldType->setInterfaceBlockField(interfaceBlock, memberIndex);

           fieldType->setQualifier(typeQualifier.qualifier);

           SymbolType symbolType = SymbolType::UserDefined;
           if (field->name() == "gl_Position" || field->name() == "gl_PointSize" ||
               field->name() == "gl_ClipDistance" || field->name() == "gl_CullDistance")
           {
               // These builtins can be redifined only when used within a redefiend gl_PerVertex
               // block
               if (interfaceBlock->name() != "gl_PerVertex")
               {
                   error(field->line(), "redefinition in an invalid interface block",
                         field->name());
               }
               symbolType = SymbolType::BuiltIn;
           }
           TVariable *fieldVariable =
               new TVariable(&symbolTable, field->name(), fieldType, symbolType);
           if (!symbolTable.declare(fieldVariable))
           {
               error(field->line(), "redefinition of an interface block member name",
                     field->name());
           }
       }
   }
   else
   {
       checkIsNotReserved(instanceLine, instanceName);

       // add a symbol for this interface block
       if (!symbolTable.declare(instanceVariable))
       {
           error(instanceLine, "redefinition of an interface block instance name", instanceName);
       }
   }

   TIntermSymbol *blockSymbol = new TIntermSymbol(instanceVariable);
   blockSymbol->setLine(typeQualifier.line);
   TIntermDeclaration *declaration = new TIntermDeclaration();
   declaration->appendDeclarator(blockSymbol);
   declaration->setLine(nameLine);

   exitStructDeclaration();
   return declaration;
}

void TParseContext::enterStructDeclaration(const TSourceLoc &line,
                                          const ImmutableString &identifier)
{
   ++mStructNestingLevel;

   // Embedded structure definitions are not supported per GLSL ES spec.
   // ESSL 1.00.17 section 10.9. ESSL 3.00.6 section 12.11.
   if (mStructNestingLevel > 1)
   {
       error(line, "Embedded struct definitions are not allowed", "struct");
   }
}

void TParseContext::exitStructDeclaration()
{
   --mStructNestingLevel;
}

void TParseContext::checkIsBelowStructNestingLimit(const TSourceLoc &line, const TField &field)
{
   if (!sh::IsWebGLBasedSpec(mShaderSpec))
   {
       return;
   }

   if (field.type()->getBasicType() != EbtStruct)
   {
       return;
   }

   // We're already inside a structure definition at this point, so add
   // one to the field's struct nesting.
   if (1 + field.type()->getDeepestStructNesting() > kWebGLMaxStructNesting)
   {
       std::stringstream reasonStream = sh::InitializeStream<std::stringstream>();
       if (field.type()->getStruct()->symbolType() == SymbolType::Empty)
       {
           // This may happen in case there are nested struct definitions. While they are also
           // invalid GLSL, they don't cause a syntax error.
           reasonStream << "Struct nesting";
       }
       else
       {
           reasonStream << "Reference of struct type " << field.type()->getStruct()->name();
       }
       reasonStream << " exceeds maximum allowed nesting level of " << kWebGLMaxStructNesting;
       std::string reason = reasonStream.str();
       error(line, reason.c_str(), field.name());
       return;
   }
}

//
// Parse an array index expression
//
TIntermTyped *TParseContext::addIndexExpression(TIntermTyped *baseExpression,
                                               const TSourceLoc &location,
                                               TIntermTyped *indexExpression)
{
   if (!baseExpression->isArray() && !baseExpression->isMatrix() && !baseExpression->isVector())
   {
       if (baseExpression->getAsSymbolNode())
       {
           error(location, " left of '[' is not of type array, matrix, or vector ",
                 baseExpression->getAsSymbolNode()->getName());
       }
       else
       {
           error(location, " left of '[' is not of type array, matrix, or vector ", "expression");
       }

       return CreateZeroNode(TType(EbtFloat, EbpHigh, EvqConst));
   }

   if (baseExpression->getQualifier() == EvqPerVertexIn)
   {
       if (mGeometryShaderInputPrimitiveType == EptUndefined &&
           mShaderType == GL_GEOMETRY_SHADER_EXT)
       {
           error(location, "missing input primitive declaration before indexing gl_in.", "[");
           return CreateZeroNode(TType(EbtFloat, EbpHigh, EvqConst));
       }
   }

   TIntermConstantUnion *indexConstantUnion = indexExpression->getAsConstantUnion();

   // ES3.2 or ES3.1's EXT_gpu_shader5 allow dynamically uniform expressions to be used as indices
   // of opaque types (samplers and atomic counters) as well as UBOs, but not SSBOs and images.
   bool allowUniformIndices =
       mShaderVersion >= 320 || isExtensionEnabled(TExtension::EXT_gpu_shader5);

   // ANGLE should be able to fold any constant expressions resulting in an integer - but to be
   // safe we don't treat "EvqConst" that's evaluated according to the spec as being sufficient
   // for constness. Some interpretations of the spec have allowed constant expressions with side
   // effects - like array length() method on a non-constant array.
   if (indexExpression->getQualifier() != EvqConst || indexConstantUnion == nullptr)
   {
       if (baseExpression->isInterfaceBlock())
       {
           switch (baseExpression->getQualifier())
           {
               case EvqPerVertexIn:
                   break;
               case EvqUniform:
                   if (!allowUniformIndices)
                   {
                       error(location,
                             "array indexes for uniform block arrays must be constant integral "
                             "expressions",
                             "[");
                   }
                   break;
               case EvqBuffer:
                   error(location,
                         "array indexes for shader storage block arrays must be constant integral "
                         "expressions",
                         "[");
                   break;
               default:
                   // It's ok for shader I/O blocks to be dynamically indexed
                   if (!IsShaderIoBlock(baseExpression->getQualifier()) &&
                       baseExpression->getQualifier() != EvqPatchIn &&
                       baseExpression->getQualifier() != EvqPatchOut)
                   {
                       // We can reach here only in error cases.
                       ASSERT(mDiagnostics->numErrors() > 0);
                   }
                   break;
           }
       }
       else if (baseExpression->getQualifier() == EvqFragmentOut)
       {
           error(location,
                 "array indexes for fragment outputs must be constant integral expressions", "[");
       }
       else if (mShaderSpec == SH_WEBGL2_SPEC && baseExpression->getQualifier() == EvqFragData)
       {
           error(location, "array index for gl_FragData must be constant zero", "[");
       }
       else if (baseExpression->isArray())
       {
           TBasicType elementType = baseExpression->getType().getBasicType();

           // Note: In Section 12.30 of the ESSL 3.00 spec on p143-144:
           //
           //   Indexing of arrays of samplers by constant-index-expressions is
           //   supported in GLSL ES 1.00. A constant-index-expression is an
           //   expression formed from constant-expressions and certain loop indices,
           //   defined for a subset of loop constructs. Should this functionality be
           //   included in GLSL ES 3.00?
           //
           //   RESOLUTION: No. Arrays of samplers may only be indexed by constant-
           //   integral-expressions.
           if (IsSampler(elementType) && !allowUniformIndices && mShaderVersion > 100)
           {
               error(location, "array index for samplers must be constant integral expressions",
                     "[");
           }
           else if (IsImage(elementType))
           {
               error(location,
                     "array indexes for image arrays must be constant integral expressions", "[");
           }
       }
   }

   if (indexConstantUnion)
   {
       // If an out-of-range index is not qualified as constant, the behavior in the spec is
       // undefined. This applies even if ANGLE has been able to constant fold it (ANGLE may
       // constant fold expressions that are not constant expressions). The most compatible way to
       // handle this case is to report a warning instead of an error and force the index to be in
       // the correct range.
       bool outOfRangeIndexIsError = indexExpression->getQualifier() == EvqConst;
       int index                   = 0;
       if (indexConstantUnion->getBasicType() == EbtInt)
       {
           index = indexConstantUnion->getIConst(0);
       }
       else if (indexConstantUnion->getBasicType() == EbtUInt)
       {
           index = static_cast<int>(indexConstantUnion->getUConst(0));
       }

       int safeIndex = -1;

       if (index < 0)
       {
           outOfRangeError(outOfRangeIndexIsError, location, "index expression is negative", "[]");
           safeIndex = 0;
       }

       if (!baseExpression->getType().isUnsizedArray())
       {
           if (baseExpression->isArray())
           {
               if (baseExpression->getQualifier() == EvqFragData && index > 0)
               {
                   if (!isExtensionEnabled(TExtension::EXT_draw_buffers))
                   {
                       outOfRangeError(outOfRangeIndexIsError, location,
                                       "array index for gl_FragData must be zero when "
                                       "GL_EXT_draw_buffers is disabled",
                                       "[]");
                       safeIndex = 0;
                   }
               }
           }
           // Only do generic out-of-range check if similar error hasn't already been reported.
           if (safeIndex < 0)
           {
               if (baseExpression->isArray())
               {
                   safeIndex = checkIndexLessThan(outOfRangeIndexIsError, location, index,
                                                  baseExpression->getOutermostArraySize(),
                                                  "array index out of range");
               }
               else if (baseExpression->isMatrix())
               {
                   safeIndex = checkIndexLessThan(outOfRangeIndexIsError, location, index,
                                                  baseExpression->getType().getCols(),
                                                  "matrix field selection out of range");
               }
               else
               {
                   ASSERT(baseExpression->isVector());
                   safeIndex = checkIndexLessThan(outOfRangeIndexIsError, location, index,
                                                  baseExpression->getType().getNominalSize(),
                                                  "vector field selection out of range");
               }
           }

           ASSERT(safeIndex >= 0);
           // Data of constant unions can't be changed, because it may be shared with other
           // constant unions or even builtins, like gl_MaxDrawBuffers. Instead use a new
           // sanitized object.
           if (safeIndex != index || indexConstantUnion->getBasicType() != EbtInt)
           {
               TConstantUnion *safeConstantUnion = new TConstantUnion();
               safeConstantUnion->setIConst(safeIndex);
               indexExpression =
                   new TIntermConstantUnion(safeConstantUnion, TType(indexExpression->getType()));
           }

           TIntermBinary *node =
               new TIntermBinary(EOpIndexDirect, baseExpression, indexExpression);
           node->setLine(location);
           return expressionOrFoldedResult(node);
       }
   }

   markStaticReadIfSymbol(indexExpression);
   TIntermBinary *node = new TIntermBinary(EOpIndexIndirect, baseExpression, indexExpression);
   node->setLine(location);
   // Indirect indexing can never be constant folded.
   return node;
}

int TParseContext::checkIndexLessThan(bool outOfRangeIndexIsError,
                                     const TSourceLoc &location,
                                     int index,
                                     int arraySize,
                                     const char *reason)
{
   // Should not reach here with an unsized / runtime-sized array.
   ASSERT(arraySize > 0);
   // A negative index should already have been checked.
   ASSERT(index >= 0);
   if (index >= arraySize)
   {
       std::stringstream reasonStream = sh::InitializeStream<std::stringstream>();
       reasonStream << reason << " '" << index << "'";
       std::string token = reasonStream.str();
       outOfRangeError(outOfRangeIndexIsError, location, reason, "[]");
       return arraySize - 1;
   }
   return index;
}

TIntermTyped *TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpression,
                                                        const TSourceLoc &dotLocation,
                                                        const ImmutableString &fieldString,
                                                        const TSourceLoc &fieldLocation)
{
   if (baseExpression->isArray())
   {
       error(fieldLocation, "cannot apply dot operator to an array", ".");
       return baseExpression;
   }

   if (baseExpression->isVector())
   {
       TVector<int> fieldOffsets;
       if (!parseVectorFields(fieldLocation, fieldString, baseExpression->getNominalSize(),
                              &fieldOffsets))
       {
           fieldOffsets.resize(1);
           fieldOffsets[0] = 0;
       }
       TIntermSwizzle *node = new TIntermSwizzle(baseExpression, fieldOffsets);
       node->setLine(dotLocation);

       return node->fold(mDiagnostics);
   }
   else if (baseExpression->getBasicType() == EbtStruct)
   {
       const TFieldList &fields = baseExpression->getType().getStruct()->fields();
       if (fields.empty())
       {
           error(dotLocation, "structure has no fields", "Internal Error");
           return baseExpression;
       }
       else
       {
           bool fieldFound = false;
           unsigned int i;
           for (i = 0; i < fields.size(); ++i)
           {
               if (fields[i]->name() == fieldString)
               {
                   fieldFound = true;
                   break;
               }
           }
           if (fieldFound)
           {
               TIntermTyped *index = CreateIndexNode(i);
               index->setLine(fieldLocation);
               TIntermBinary *node =
                   new TIntermBinary(EOpIndexDirectStruct, baseExpression, index);
               node->setLine(dotLocation);
               return expressionOrFoldedResult(node);
           }
           else
           {
               error(dotLocation, " no such field in structure", fieldString);
               return baseExpression;
           }
       }
   }
   else if (baseExpression->isInterfaceBlock())
   {
       const TFieldList &fields = baseExpression->getType().getInterfaceBlock()->fields();
       if (fields.empty())
       {
           error(dotLocation, "interface block has no fields", "Internal Error");
           return baseExpression;
       }
       else
       {
           bool fieldFound = false;
           unsigned int i;
           for (i = 0; i < fields.size(); ++i)
           {
               if (fields[i]->name() == fieldString)
               {
                   fieldFound = true;
                   break;
               }
           }
           if (fieldFound)
           {
               TIntermTyped *index = CreateIndexNode(i);
               index->setLine(fieldLocation);
               TIntermBinary *node =
                   new TIntermBinary(EOpIndexDirectInterfaceBlock, baseExpression, index);
               node->setLine(dotLocation);
               // Indexing interface blocks can never be constant folded.
               return node;
           }
           else
           {
               error(dotLocation, " no such field in interface block", fieldString);
               return baseExpression;
           }
       }
   }
   else
   {
       if (mShaderVersion < 300)
       {
           error(dotLocation, " field selection requires structure or vector on left hand side",
                 fieldString);
       }
       else
       {
           error(dotLocation,
                 " field selection requires structure, vector, or interface block on left hand "
                 "side",
                 fieldString);
       }
       return baseExpression;
   }
}

TLayoutQualifier TParseContext::parseLayoutQualifier(const ImmutableString &qualifierType,
                                                    const TSourceLoc &qualifierTypeLine)
{
   TLayoutQualifier qualifier = TLayoutQualifier::Create();

   if (qualifierType == "shared")
   {
       if (sh::IsWebGLBasedSpec(mShaderSpec))
       {
           error(qualifierTypeLine, "Only std140 layout is allowed in WebGL", "shared");
       }
       qualifier.blockStorage = EbsShared;
   }
   else if (qualifierType == "packed")
   {
       if (sh::IsWebGLBasedSpec(mShaderSpec))
       {
           error(qualifierTypeLine, "Only std140 layout is allowed in WebGL", "packed");
       }
       qualifier.blockStorage = EbsPacked;
   }
   else if (qualifierType == "std430")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.blockStorage = EbsStd430;
   }
   else if (qualifierType == "std140")
   {
       qualifier.blockStorage = EbsStd140;
   }
   else if (qualifierType == "row_major")
   {
       qualifier.matrixPacking = EmpRowMajor;
   }
   else if (qualifierType == "column_major")
   {
       qualifier.matrixPacking = EmpColumnMajor;
   }
   else if (qualifierType == "location")
   {
       error(qualifierTypeLine, "invalid layout qualifier: location requires an argument",
             qualifierType);
   }
   else if (qualifierType == "yuv" && mShaderType == GL_FRAGMENT_SHADER)
   {
       if (checkCanUseExtension(qualifierTypeLine, TExtension::EXT_YUV_target))
       {
           qualifier.yuv = true;
       }
   }
   else if (qualifierType == "early_fragment_tests")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.earlyFragmentTests = true;
   }
   else if (qualifierType == "rgba32f")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA32F;
   }
   else if (qualifierType == "rgba16f")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA16F;
   }
   else if (qualifierType == "r32f")
   {
       if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
       {
           checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       }
       qualifier.imageInternalFormat = EiifR32F;
   }
   else if (qualifierType == "rgba8")
   {
       if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
       {
           checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       }
       qualifier.imageInternalFormat = EiifRGBA8;
   }
   else if (qualifierType == "rgba8_snorm")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA8_SNORM;
   }
   else if (qualifierType == "rgba32i")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA32I;
   }
   else if (qualifierType == "rgba16i")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA16I;
   }
   else if (qualifierType == "rgba8i")
   {
       if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
       {
           checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       }
       qualifier.imageInternalFormat = EiifRGBA8I;
   }
   else if (qualifierType == "r32i")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifR32I;
   }
   else if (qualifierType == "rgba32ui")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA32UI;
   }
   else if (qualifierType == "rgba16ui")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       qualifier.imageInternalFormat = EiifRGBA16UI;
   }
   else if (qualifierType == "rgba8ui")
   {
       if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
       {
           checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       }
       qualifier.imageInternalFormat = EiifRGBA8UI;
   }
   else if (qualifierType == "r32ui")
   {
       if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
       {
           checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       }
       qualifier.imageInternalFormat = EiifR32UI;
   }
   else if (mShaderType == GL_GEOMETRY_SHADER_EXT &&
            (mShaderVersion >= 320 ||
             (checkCanUseOneOfExtensions(
                  qualifierTypeLine,
                  std::array<TExtension, 2u>{
                      {TExtension::EXT_geometry_shader, TExtension::OES_geometry_shader}}) &&
              checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310))))
   {
       if (qualifierType == "points")
       {
           qualifier.primitiveType = EptPoints;
       }
       else if (qualifierType == "lines")
       {
           qualifier.primitiveType = EptLines;
       }
       else if (qualifierType == "lines_adjacency")
       {
           qualifier.primitiveType = EptLinesAdjacency;
       }
       else if (qualifierType == "triangles")
       {
           qualifier.primitiveType = EptTriangles;
       }
       else if (qualifierType == "triangles_adjacency")
       {
           qualifier.primitiveType = EptTrianglesAdjacency;
       }
       else if (qualifierType == "line_strip")
       {
           qualifier.primitiveType = EptLineStrip;
       }
       else if (qualifierType == "triangle_strip")
       {
           qualifier.primitiveType = EptTriangleStrip;
       }
       else
       {
           error(qualifierTypeLine, "invalid layout qualifier", qualifierType);
       }
   }
   else if (mShaderType == GL_TESS_EVALUATION_SHADER_EXT &&
            (mShaderVersion >= 320 ||
             (checkCanUseExtension(qualifierTypeLine, TExtension::EXT_tessellation_shader) &&
              checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310))))
   {
       if (qualifierType == "triangles")
       {
           qualifier.tesPrimitiveType = EtetTriangles;
       }
       else if (qualifierType == "quads")
       {
           qualifier.tesPrimitiveType = EtetQuads;
       }
       else if (qualifierType == "isolines")
       {
           qualifier.tesPrimitiveType = EtetIsolines;
       }
       else if (qualifierType == "equal_spacing")
       {
           qualifier.tesVertexSpacingType = EtetEqualSpacing;
       }
       else if (qualifierType == "fractional_even_spacing")
       {
           qualifier.tesVertexSpacingType = EtetFractionalEvenSpacing;
       }
       else if (qualifierType == "fractional_odd_spacing")
       {
           qualifier.tesVertexSpacingType = EtetFractionalOddSpacing;
       }
       else if (qualifierType == "cw")
       {
           qualifier.tesOrderingType = EtetCw;
       }
       else if (qualifierType == "ccw")
       {
           qualifier.tesOrderingType = EtetCcw;
       }
       else if (qualifierType == "point_mode")
       {
           qualifier.tesPointType = EtetPointMode;
       }
       else
       {
           error(qualifierTypeLine, "invalid layout qualifier", qualifierType);
       }
   }
   else if (mShaderType == GL_FRAGMENT_SHADER)
   {
       if (qualifierType == "noncoherent")
       {
           if (checkCanUseOneOfExtensions(
                   qualifierTypeLine,
                   std::array<TExtension, 2u>{
                       {TExtension::EXT_shader_framebuffer_fetch,
                        TExtension::EXT_shader_framebuffer_fetch_non_coherent}}))
           {
               checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 100);
               qualifier.noncoherent = true;
           }
       }
       else if (qualifierType == "blend_support_multiply")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Multiply, &qualifier);
       }
       else if (qualifierType == "blend_support_screen")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Screen, &qualifier);
       }
       else if (qualifierType == "blend_support_overlay")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Overlay, &qualifier);
       }
       else if (qualifierType == "blend_support_darken")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Darken, &qualifier);
       }
       else if (qualifierType == "blend_support_lighten")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Lighten, &qualifier);
       }
       else if (qualifierType == "blend_support_colordodge")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Colordodge, &qualifier);
       }
       else if (qualifierType == "blend_support_colorburn")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Colorburn, &qualifier);
       }
       else if (qualifierType == "blend_support_hardlight")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Hardlight, &qualifier);
       }
       else if (qualifierType == "blend_support_softlight")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Softlight, &qualifier);
       }
       else if (qualifierType == "blend_support_difference")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Difference, &qualifier);
       }
       else if (qualifierType == "blend_support_exclusion")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::Exclusion, &qualifier);
       }
       else if (qualifierType == "blend_support_hsl_hue")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::HslHue, &qualifier);
       }
       else if (qualifierType == "blend_support_hsl_saturation")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::HslSaturation, &qualifier);
       }
       else if (qualifierType == "blend_support_hsl_color")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::HslColor, &qualifier);
       }
       else if (qualifierType == "blend_support_hsl_luminosity")
       {
           AddAdvancedBlendEquation(gl::BlendEquationType::HslLuminosity, &qualifier);
       }
       else if (qualifierType == "blend_support_all_equations")
       {
           qualifier.advancedBlendEquations.setAll();
       }
       else
       {
           error(qualifierTypeLine, "invalid layout qualifier", qualifierType);
       }

       if (qualifier.advancedBlendEquations.any() && mShaderVersion < 320)
       {
           if (!checkCanUseExtension(qualifierTypeLine, TExtension::KHR_blend_equation_advanced))
           {
               qualifier.advancedBlendEquations.reset();
           }
       }
   }
   else
   {
       error(qualifierTypeLine, "invalid layout qualifier", qualifierType);
   }

   return qualifier;
}

void TParseContext::parseLocalSize(const ImmutableString &qualifierType,
                                  const TSourceLoc &qualifierTypeLine,
                                  int intValue,
                                  const TSourceLoc &intValueLine,
                                  const std::string &intValueString,
                                  size_t index,
                                  sh::WorkGroupSize *localSize)
{
   checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
   if (intValue < 1)
   {
       std::stringstream reasonStream = sh::InitializeStream<std::stringstream>();
       reasonStream << "out of range: " << getWorkGroupSizeString(index) << " must be positive";
       std::string reason = reasonStream.str();
       error(intValueLine, reason.c_str(), intValueString.c_str());
   }
   (*localSize)[index] = intValue;
}

void TParseContext::parseNumViews(int intValue,
                                 const TSourceLoc &intValueLine,
                                 const std::string &intValueString,
                                 int *numViews)
{
   // This error is only specified in WebGL, but tightens unspecified behavior in the native
   // specification.
   if (intValue < 1)
   {
       error(intValueLine, "out of range: num_views must be positive", intValueString.c_str());
   }
   *numViews = intValue;
}

void TParseContext::parseInvocations(int intValue,
                                    const TSourceLoc &intValueLine,
                                    const std::string &intValueString,
                                    int *numInvocations)
{
   // Although SPEC isn't clear whether invocations can be less than 1, we add this limit because
   // it doesn't make sense to accept invocations <= 0.
   if (intValue < 1 || intValue > mMaxGeometryShaderInvocations)
   {
       error(intValueLine,
             "out of range: invocations must be in the range of [1, "
             "MAX_GEOMETRY_SHADER_INVOCATIONS_OES]",
             intValueString.c_str());
   }
   else
   {
       *numInvocations = intValue;
   }
}

void TParseContext::parseMaxVertices(int intValue,
                                    const TSourceLoc &intValueLine,
                                    const std::string &intValueString,
                                    int *maxVertices)
{
   // Although SPEC isn't clear whether max_vertices can be less than 0, we add this limit because
   // it doesn't make sense to accept max_vertices < 0.
   if (intValue < 0 || intValue > mMaxGeometryShaderMaxVertices)
   {
       error(
           intValueLine,
           "out of range: max_vertices must be in the range of [0, gl_MaxGeometryOutputVertices]",
           intValueString.c_str());
   }
   else
   {
       *maxVertices = intValue;
   }
}

void TParseContext::parseVertices(int intValue,
                                 const TSourceLoc &intValueLine,
                                 const std::string &intValueString,
                                 int *vertices)
{
   if (intValue < 1 || intValue > mMaxPatchVertices)
   {
       error(intValueLine,
             "out of range : vertices must be in the range of [1, gl_MaxPatchVertices]",
             intValueString.c_str());
   }
   else
   {
       *vertices = intValue;
   }
}

void TParseContext::parseIndexLayoutQualifier(int intValue,
                                             const TSourceLoc &intValueLine,
                                             const std::string &intValueString,
                                             int *index)
{
   // EXT_blend_func_extended specifies that most validation should happen at link time, but since
   // we're validating output variable locations at compile time, it makes sense to validate that
   // index is 0 or 1 also at compile time. Also since we use "-1" as a placeholder for unspecified
   // index, we can't accept it here.
   if (intValue < 0 || intValue > 1)
   {
       error(intValueLine, "out of range: index layout qualifier can only be 0 or 1",
             intValueString.c_str());
   }
   else
   {
       *index = intValue;
   }
}

TLayoutQualifier TParseContext::parseLayoutQualifier(const ImmutableString &qualifierType,
                                                    const TSourceLoc &qualifierTypeLine,
                                                    int intValue,
                                                    const TSourceLoc &intValueLine)
{
   TLayoutQualifier qualifier = TLayoutQualifier::Create();

   std::string intValueString = Str(intValue);

   if (qualifierType == "location")
   {
       // must check that location is non-negative
       if (intValue < 0)
       {
           error(intValueLine, "out of range: location must be non-negative",
                 intValueString.c_str());
       }
       else
       {
           qualifier.location           = intValue;
           qualifier.locationsSpecified = 1;
       }
   }
   else if (qualifierType == "binding")
   {
       if (!isExtensionEnabled(TExtension::ANGLE_shader_pixel_local_storage))
       {
           checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       }
       if (intValue < 0)
       {
           error(intValueLine, "out of range: binding must be non-negative",
                 intValueString.c_str());
       }
       else
       {
           qualifier.binding = intValue;
       }
   }
   else if (qualifierType == "offset")
   {
       checkLayoutQualifierSupported(qualifierTypeLine, qualifierType, 310);
       if (intValue < 0)
       {
           error(intValueLine, "out of range: offset must be non-negative",
                 intValueString.c_str());
       }
       else
       {
           qualifier.offset = intValue;
       }
   }
   else if (qualifierType == "local_size_x")
   {
       parseLocalSize(qualifierType, qualifierTypeLine, intValue, intValueLine, intValueString, 0u,
                      &qualifier.localSize);
   }
   else if (qualifierType == "local_size_y")
   {
       parseLocalSize(qualifierType, qualifierTypeLine, intValue, intValueLine, intValueString, 1u,
                      &qualifier.localSize);
   }
   else if (qualifierType == "local_size_z")
   {
       parseLocalSize(qualifierType, qualifierTypeLine, intValue, intValueLine, intValueString, 2u,
                      &qualifier.localSize);
   }
   else if (qualifierType == "num_views" && mShaderType == GL_VERTEX_SHADER)
   {
       if (checkCanUseOneOfExtensions(
               qualifierTypeLine, std::array<TExtension, 2u>{
                                      {TExtension::OVR_multiview, TExtension::OVR_multiview2}}))
       {
           parseNumViews(intValue, intValueLine, intValueString, &qualifier.numViews);
       }
   }
   else if (qualifierType == "invocations" && mShaderType == GL_GEOMETRY_SHADER_EXT &&
            (mShaderVersion >= 320 ||
             checkCanUseOneOfExtensions(
                 qualifierTypeLine,
                 std::array<TExtension, 2u>{
                     {TExtension::EXT_geometry_shader, TExtension::OES_geometry_shader}})))
   {
       parseInvocations(intValue, intValueLine, intValueString, &qualifier.invocations);
   }
   else if (qualifierType == "max_vertices" && mShaderType == GL_GEOMETRY_SHADER_EXT &&
            (mShaderVersion >= 320 ||
             checkCanUseOneOfExtensions(
                 qualifierTypeLine,
                 std::array<TExtension, 2u>{
                     {TExtension::EXT_geometry_shader, TExtension::OES_geometry_shader}})))
   {
       parseMaxVertices(intValue, intValueLine, intValueString, &qualifier.maxVertices);
   }
   else if (qualifierType == "index" && mShaderType == GL_FRAGMENT_SHADER &&
            checkCanUseExtension(qualifierTypeLine, TExtension::EXT_blend_func_extended))
   {
       parseIndexLayoutQualifier(intValue, intValueLine, intValueString, &qualifier.index);
   }
   else if (qualifierType == "vertices" && mShaderType == GL_TESS_CONTROL_SHADER_EXT &&
            (mShaderVersion >= 320 ||
             checkCanUseExtension(qualifierTypeLine, TExtension::EXT_tessellation_shader)))
   {
       parseVertices(intValue, intValueLine, intValueString, &qualifier.vertices);
   }
   else
   {
       error(qualifierTypeLine, "invalid layout qualifier", qualifierType);
   }

   return qualifier;
}

TTypeQualifierBuilder *TParseContext::createTypeQualifierBuilder(const TSourceLoc &loc)
{
   return new TTypeQualifierBuilder(
       new TStorageQualifierWrapper(symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary, loc),
       mShaderVersion);
}

TStorageQualifierWrapper *TParseContext::parseGlobalStorageQualifier(TQualifier qualifier,
                                                                    const TSourceLoc &loc)
{
   checkIsAtGlobalLevel(loc, getQualifierString(qualifier));
   return new TStorageQualifierWrapper(qualifier, loc);
}

TStorageQualifierWrapper *TParseContext::parseVaryingQualifier(const TSourceLoc &loc)
{
   if (getShaderType() == GL_VERTEX_SHADER)
   {
       return parseGlobalStorageQualifier(EvqVaryingOut, loc);
   }
   return parseGlobalStorageQualifier(EvqVaryingIn, loc);
}

TStorageQualifierWrapper *TParseContext::parseInQualifier(const TSourceLoc &loc)
{
   if (declaringFunction())
   {
       return new TStorageQualifierWrapper(EvqParamIn, loc);
   }

   switch (getShaderType())
   {
       case GL_VERTEX_SHADER:
       {
           if (mShaderVersion < 300 && !anyMultiviewExtensionAvailable() &&
               !IsDesktopGLSpec(mShaderSpec))
           {
               error(loc, "storage qualifier supported in GLSL ES 3.00 and above only", "in");
           }
           return new TStorageQualifierWrapper(EvqVertexIn, loc);
       }
       case GL_FRAGMENT_SHADER:
       {
           if (mShaderVersion < 300 && !IsDesktopGLSpec(mShaderSpec))
           {
               error(loc, "storage qualifier supported in GLSL ES 3.00 and above only", "in");
           }
           return new TStorageQualifierWrapper(EvqFragmentIn, loc);
       }
       case GL_COMPUTE_SHADER:
       {
           return new TStorageQualifierWrapper(EvqComputeIn, loc);
       }
       case GL_GEOMETRY_SHADER:
       {
           return new TStorageQualifierWrapper(EvqGeometryIn, loc);
       }
       case GL_TESS_CONTROL_SHADER:
       {
           return new TStorageQualifierWrapper(EvqTessControlIn, loc);
       }
       case GL_TESS_EVALUATION_SHADER:
       {
           return new TStorageQualifierWrapper(EvqTessEvaluationIn, loc);
       }
       default:
       {
           UNREACHABLE();
           return new TStorageQualifierWrapper(EvqLast, loc);
       }
   }
}

TStorageQualifierWrapper *TParseContext::parseOutQualifier(const TSourceLoc &loc)
{
   if (declaringFunction())
   {
       return new TStorageQualifierWrapper(EvqParamOut, loc);
   }
   switch (getShaderType())
   {
       case GL_VERTEX_SHADER:
       {
           if (mShaderVersion < 300 && !IsDesktopGLSpec(mShaderSpec))
           {
               error(loc, "storage qualifier supported in GLSL ES 3.00 and above only", "out");
           }
           return new TStorageQualifierWrapper(EvqVertexOut, loc);
       }
       case GL_FRAGMENT_SHADER:
       {
           if (mShaderVersion < 300 && !IsDesktopGLSpec(mShaderSpec))
           {
               error(loc, "storage qualifier supported in GLSL ES 3.00 and above only", "out");
           }
           return new TStorageQualifierWrapper(EvqFragmentOut, loc);
       }
       case GL_COMPUTE_SHADER:
       {
           error(loc, "storage qualifier isn't supported in compute shaders", "out");
           return new TStorageQualifierWrapper(EvqParamOut, loc);
       }
       case GL_GEOMETRY_SHADER_EXT:
       {
           return new TStorageQualifierWrapper(EvqGeometryOut, loc);
       }
       case GL_TESS_CONTROL_SHADER_EXT:
       {
           return new TStorageQualifierWrapper(EvqTessControlOut, loc);
       }
       case GL_TESS_EVALUATION_SHADER_EXT:
       {
           return new TStorageQualifierWrapper(EvqTessEvaluationOut, loc);
       }
       default:
       {
           UNREACHABLE();
           return new TStorageQualifierWrapper(EvqLast, loc);
       }
   }
}

TStorageQualifierWrapper *TParseContext::parseInOutQualifier(const TSourceLoc &loc)
{
   if (!declaringFunction())
   {
       if (mShaderVersion < 300 && !IsDesktopGLSpec(mShaderSpec))
       {
           error(loc, "storage qualifier supported in GLSL ES 3.00 and above only", "inout");
       }

       if (getShaderType() != GL_FRAGMENT_SHADER)
       {
           error(loc, "storage qualifier isn't supported in non-fragment shaders", "inout");
       }

       if (isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch) ||
           isExtensionEnabled(TExtension::EXT_shader_framebuffer_fetch_non_coherent))
       {
           return new TStorageQualifierWrapper(EvqFragmentInOut, loc);
       }

       error(loc,
             "invalid qualifier: can be used with either function parameters or the variables for "
             "fetching input attachment data",
             "inout");
   }
   return new TStorageQualifierWrapper(EvqParamInOut, loc);
}

TLayoutQualifier TParseContext::joinLayoutQualifiers(TLayoutQualifier leftQualifier,
                                                    TLayoutQualifier rightQualifier,
                                                    const TSourceLoc &rightQualifierLocation)
{
   return sh::JoinLayoutQualifiers(leftQualifier, rightQualifier, rightQualifierLocation,
                                   mDiagnostics);
}

TDeclarator *TParseContext::parseStructDeclarator(const ImmutableString &identifier,
                                                 const TSourceLoc &loc)
{
   return new TDeclarator(identifier, loc);
}

TDeclarator *TParseContext::parseStructArrayDeclarator(const ImmutableString &identifier,
                                                      const TSourceLoc &loc,
                                                      const TVector<unsigned int> *arraySizes)
{
   return new TDeclarator(identifier, arraySizes, loc);
}

void TParseContext::checkDoesNotHaveDuplicateFieldName(const TFieldList::const_iterator begin,
                                                      const TFieldList::const_iterator end,
                                                      const ImmutableString &name,
                                                      const TSourceLoc &location)
{
   for (auto fieldIter = begin; fieldIter != end; ++fieldIter)
   {
       if ((*fieldIter)->name() == name)
       {
           error(location, "duplicate field name in structure", name);
       }
   }
}

TFieldList *TParseContext::addStructFieldList(TFieldList *fields, const TSourceLoc &location)
{
   for (TFieldList::const_iterator fieldIter = fields->begin(); fieldIter != fields->end();
        ++fieldIter)
   {
       checkDoesNotHaveDuplicateFieldName(fields->begin(), fieldIter, (*fieldIter)->name(),
                                          location);
   }
   return fields;
}

TFieldList *TParseContext::combineStructFieldLists(TFieldList *processedFields,
                                                  const TFieldList *newlyAddedFields,
                                                  const TSourceLoc &location)
{
   for (TField *field : *newlyAddedFields)
   {
       checkDoesNotHaveDuplicateFieldName(processedFields->begin(), processedFields->end(),
                                          field->name(), location);
       processedFields->push_back(field);
   }
   return processedFields;
}

TFieldList *TParseContext::addStructDeclaratorListWithQualifiers(
   const TTypeQualifierBuilder &typeQualifierBuilder,
   TPublicType *typeSpecifier,
   const TDeclaratorList *declaratorList)
{
   TTypeQualifier typeQualifier = typeQualifierBuilder.getVariableTypeQualifier(mDiagnostics);

   typeSpecifier->qualifier       = typeQualifier.qualifier;
   typeSpecifier->layoutQualifier = typeQualifier.layoutQualifier;
   typeSpecifier->memoryQualifier = typeQualifier.memoryQualifier;
   typeSpecifier->invariant       = typeQualifier.invariant;
   typeSpecifier->precise         = typeQualifier.precise;
   if (typeQualifier.precision != EbpUndefined)
   {
       typeSpecifier->precision = typeQualifier.precision;
   }
   return addStructDeclaratorList(*typeSpecifier, declaratorList);
}

TFieldList *TParseContext::addStructDeclaratorList(const TPublicType &typeSpecifier,
                                                  const TDeclaratorList *declaratorList)
{
   checkPrecisionSpecified(typeSpecifier.getLine(), typeSpecifier.precision,
                           typeSpecifier.getBasicType());

   checkIsNonVoid(typeSpecifier.getLine(), (*declaratorList)[0]->name(),
                  typeSpecifier.getBasicType());

   checkWorkGroupSizeIsNotSpecified(typeSpecifier.getLine(), typeSpecifier.layoutQualifier);
   checkEarlyFragmentTestsIsNotSpecified(typeSpecifier.getLine(),
                                         typeSpecifier.layoutQualifier.earlyFragmentTests);
   checkNoncoherentIsNotSpecified(typeSpecifier.getLine(),
                                  typeSpecifier.layoutQualifier.noncoherent);

   TFieldList *fieldList = new TFieldList();

   for (const TDeclarator *declarator : *declaratorList)
   {
       TType *type = new TType(typeSpecifier);
       if (declarator->isArray())
       {
           // Don't allow arrays of arrays in ESSL < 3.10.
           checkArrayElementIsNotArray(typeSpecifier.getLine(), typeSpecifier);
           type->makeArrays(*declarator->arraySizes());
       }

       SymbolType symbolType = SymbolType::UserDefined;
       if (declarator->name() == "gl_Position" || declarator->name() == "gl_PointSize" ||
           declarator->name() == "gl_ClipDistance" || declarator->name() == "gl_CullDistance")
       {
           symbolType = SymbolType::BuiltIn;
       }
       else
       {
           checkIsNotReserved(typeSpecifier.getLine(), declarator->name());
       }
       TField *field = new TField(type, declarator->name(), declarator->line(), symbolType);
       checkIsBelowStructNestingLimit(typeSpecifier.getLine(), *field);
       fieldList->push_back(field);
   }

   return fieldList;
}

TTypeSpecifierNonArray TParseContext::addStructure(const TSourceLoc &structLine,
                                                  const TSourceLoc &nameLine,
                                                  const ImmutableString &structName,
                                                  TFieldList *fieldList)
{
   SymbolType structSymbolType = SymbolType::UserDefined;
   if (structName.empty())
   {
       structSymbolType = SymbolType::Empty;
   }
   TStructure *structure = new TStructure(&symbolTable, structName, fieldList, structSymbolType);

   // Store a bool in the struct if we're at global scope, to allow us to
   // skip the local struct scoping workaround in HLSL.
   structure->setAtGlobalScope(symbolTable.atGlobalLevel());

   if (structSymbolType != SymbolType::Empty)
   {
       checkIsNotReserved(nameLine, structName);
       if (!symbolTable.declare(structure))
       {
           error(nameLine, "redefinition of a struct", structName);
       }
   }

   // ensure we do not specify any storage qualifiers on the struct members
   for (unsigned int typeListIndex = 0; typeListIndex < fieldList->size(); typeListIndex++)
   {
       TField &field              = *(*fieldList)[typeListIndex];
       const TQualifier qualifier = field.type()->getQualifier();
       switch (qualifier)
       {
           case EvqGlobal:
           case EvqTemporary:
               break;
           default:
               error(field.line(), "invalid qualifier on struct member",
                     getQualifierString(qualifier));
               break;
       }
       if (field.type()->isInvariant())
       {
           error(field.line(), "invalid qualifier on struct member", "invariant");
       }
       // ESSL 3.10 section 4.1.8 -- atomic_uint or images are not allowed as structure member.
       // ANGLE_shader_pixel_local_storage also disallows PLS as struct members.
       if (IsImage(field.type()->getBasicType()) ||
           IsAtomicCounter(field.type()->getBasicType()) ||
           IsPixelLocal(field.type()->getBasicType()))
       {
           error(field.line(), "disallowed type in struct", field.type()->getBasicString());
       }

       checkIsNotUnsizedArray(field.line(), "array members of structs must specify a size",
                              field.name(), field.type());

       checkMemoryQualifierIsNotSpecified(field.type()->getMemoryQualifier(), field.line());

       checkIndexIsNotSpecified(field.line(), field.type()->getLayoutQualifier().index);

       checkBindingIsNotSpecified(field.line(), field.type()->getLayoutQualifier().binding);

       checkLocationIsNotSpecified(field.line(), field.type()->getLayoutQualifier());
   }

   TTypeSpecifierNonArray typeSpecifierNonArray;
   typeSpecifierNonArray.initializeStruct(structure, true, structLine);
   exitStructDeclaration();

   return typeSpecifierNonArray;
}

TIntermSwitch *TParseContext::addSwitch(TIntermTyped *init,
                                       TIntermBlock *statementList,
                                       const TSourceLoc &loc)
{
   TBasicType switchType = init->getBasicType();
   if ((switchType != EbtInt && switchType != EbtUInt) || init->isMatrix() || init->isArray() ||
       init->isVector())
   {
       error(init->getLine(), "init-expression in a switch statement must be a scalar integer",
             "switch");
       return nullptr;
   }

   ASSERT(statementList);
   if (!ValidateSwitchStatementList(switchType, mDiagnostics, statementList, loc))
   {
       ASSERT(mDiagnostics->numErrors() > 0);
       return nullptr;
   }

   markStaticReadIfSymbol(init);
   TIntermSwitch *node = new TIntermSwitch(init, statementList);
   node->setLine(loc);
   return node;
}

TIntermCase *TParseContext::addCase(TIntermTyped *condition, const TSourceLoc &loc)
{
   if (mSwitchNestingLevel == 0)
   {
       error(loc, "case labels need to be inside switch statements", "case");
       return nullptr;
   }
   if (condition == nullptr)
   {
       error(loc, "case label must have a condition", "case");
       return nullptr;
   }
   if ((condition->getBasicType() != EbtInt && condition->getBasicType() != EbtUInt) ||
       condition->isMatrix() || condition->isArray() || condition->isVector())
   {
       error(condition->getLine(), "case label must be a scalar integer", "case");
   }
   TIntermConstantUnion *conditionConst = condition->getAsConstantUnion();
   // ANGLE should be able to fold any EvqConst expressions resulting in an integer - but to be
   // safe against corner cases we still check for conditionConst. Some interpretations of the
   // spec have allowed constant expressions with side effects - like array length() method on a
   // non-constant array.
   if (condition->getQualifier() != EvqConst || conditionConst == nullptr)
   {
       error(condition->getLine(), "case label must be constant", "case");
   }
   TIntermCase *node = new TIntermCase(condition);
   node->setLine(loc);
   return node;
}

TIntermCase *TParseContext::addDefault(const TSourceLoc &loc)
{
   if (mSwitchNestingLevel == 0)
   {
       error(loc, "default labels need to be inside switch statements", "default");
       return nullptr;
   }
   TIntermCase *node = new TIntermCase(nullptr);
   node->setLine(loc);
   return node;
}

TIntermTyped *TParseContext::createUnaryMath(TOperator op,
                                            TIntermTyped *child,
                                            const TSourceLoc &loc,
                                            const TFunction *func)
{
   ASSERT(child != nullptr);

   switch (op)
   {
       case EOpLogicalNot:
           if (child->getBasicType() != EbtBool || child->isMatrix() || child->isArray() ||
               child->isVector())
           {
               unaryOpError(loc, GetOperatorString(op), child->getType());
               return nullptr;
           }
           break;
       case EOpBitwiseNot:
           if ((child->getBasicType() != EbtInt && child->getBasicType() != EbtUInt) ||
               child->isMatrix() || child->isArray())
           {
               unaryOpError(loc, GetOperatorString(op), child->getType());
               return nullptr;
           }
           break;
       case EOpPostIncrement:
       case EOpPreIncrement:
       case EOpPostDecrement:
       case EOpPreDecrement:
       case EOpNegative:
       case EOpPositive:
           if (child->getBasicType() == EbtStruct || child->isInterfaceBlock() ||
               child->getBasicType() == EbtBool || child->isArray() ||
               child->getBasicType() == EbtVoid || IsOpaqueType(child->getBasicType()))
           {
               unaryOpError(loc, GetOperatorString(op), child->getType());
               return nullptr;
           }
           break;
       // Operators for math built-ins are already type checked against their prototype.
       default:
           break;
   }

   if (child->getMemoryQualifier().writeonly)
   {
       const char *opStr =
           BuiltInGroup::IsBuiltIn(op) ? func->name().data() : GetOperatorString(op);
       unaryOpError(loc, opStr, child->getType());
       return nullptr;
   }

   markStaticReadIfSymbol(child);
   TIntermUnary *node = new TIntermUnary(op, child, func);
   node->setLine(loc);

   return node->fold(mDiagnostics);
}

TIntermTyped *TParseContext::addUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc)
{
   ASSERT(op != EOpNull);
   TIntermTyped *node = createUnaryMath(op, child, loc, nullptr);
   if (node == nullptr)
   {
       return child;
   }
   return node;
}

TIntermTyped *TParseContext::addUnaryMathLValue(TOperator op,
                                               TIntermTyped *child,
                                               const TSourceLoc &loc)
{
   checkCanBeLValue(loc, GetOperatorString(op), child);
   return addUnaryMath(op, child, loc);
}

TIntermTyped *TParseContext::expressionOrFoldedResult(TIntermTyped *expression)
{
   // If we can, we should return the folded version of the expression for subsequent parsing. This
   // enables folding the containing expression during parsing as well, instead of the separate
   // FoldExpressions() step where folding nested expressions requires multiple full AST
   // traversals.

   // Even if folding fails the fold() functions return some node representing the expression,
   // typically the original node. So "folded" can be assumed to be non-null.
   TIntermTyped *folded = expression->fold(mDiagnostics);
   ASSERT(folded != nullptr);
   if (folded->getQualifier() == expression->getQualifier())
   {
       // We need this expression to have the correct qualifier when validating the consuming
       // expression. So we can only return the folded node from here in case it has the same
       // qualifier as the original expression. In this kind of a cases the qualifier of the folded
       // node is EvqConst, whereas the qualifier of the expression is EvqTemporary:
       //  1. (true ? 1.0 : non_constant)
       //  2. (non_constant, 1.0)
       return folded;
   }
   return expression;
}

bool TParseContext::binaryOpCommonCheck(TOperator op,
                                       TIntermTyped *left,
                                       TIntermTyped *right,
                                       const TSourceLoc &loc)
{
   // Check opaque types are not allowed to be operands in expressions other than array indexing
   // and structure member selection.
   if (IsOpaqueType(left->getBasicType()) || IsOpaqueType(right->getBasicType()))
   {
       switch (op)
       {
           case EOpIndexDirect:
           case EOpIndexIndirect:
               break;

           default:
               ASSERT(op != EOpIndexDirectStruct);
               error(loc, "Invalid operation for variables with an opaque type",
                     GetOperatorString(op));
               return false;
       }
   }

   if (right->getMemoryQualifier().writeonly)
   {
       error(loc, "Invalid operation for variables with writeonly", GetOperatorString(op));
       return false;
   }

   if (left->getMemoryQualifier().writeonly)
   {
       switch (op)
       {
           case EOpAssign:
           case EOpInitialize:
           case EOpIndexDirect:
           case EOpIndexIndirect:
           case EOpIndexDirectStruct:
           case EOpIndexDirectInterfaceBlock:
               break;
           default:
               error(loc, "Invalid operation for variables with writeonly", GetOperatorString(op));
               return false;
       }
   }

   if (left->getType().getStruct() || right->getType().getStruct())
   {
       switch (op)
       {
           case EOpIndexDirectStruct:
               ASSERT(left->getType().getStruct());
               break;
           case EOpEqual:
           case EOpNotEqual:
           case EOpAssign:
           case EOpInitialize:
               if (left->getType() != right->getType())
               {
                   return false;
               }
               break;
           default:
               error(loc, "Invalid operation for structs", GetOperatorString(op));
               return false;
       }
   }

   if (left->isInterfaceBlock() || right->isInterfaceBlock())
   {
       switch (op)
       {
           case EOpIndexDirectInterfaceBlock:
               ASSERT(left->getType().getInterfaceBlock());
               break;
           default:
               error(loc, "Invalid operation for interface blocks", GetOperatorString(op));
               return false;
       }
   }

   if (left->isArray() != right->isArray())
   {
       error(loc, "array / non-array mismatch", GetOperatorString(op));
       return false;
   }

   if (left->isArray())
   {
       ASSERT(right->isArray());
       if (mShaderVersion < 300)
       {
           error(loc, "Invalid operation for arrays", GetOperatorString(op));
           return false;
       }

       switch (op)
       {
           case EOpEqual:
           case EOpNotEqual:
           case EOpAssign:
           case EOpInitialize:
               break;
           default:
               error(loc, "Invalid operation for arrays", GetOperatorString(op));
               return false;
       }
       // At this point, size of implicitly sized arrays should be resolved.
       if (left->getType().getArraySizes() != right->getType().getArraySizes())
       {
           error(loc, "array size mismatch", GetOperatorString(op));
           return false;
       }
   }

   // Check ops which require integer / ivec parameters
   bool isBitShift = false;
   switch (op)
   {
       case EOpBitShiftLeft:
       case EOpBitShiftRight:
       case EOpBitShiftLeftAssign:
       case EOpBitShiftRightAssign:
           // Unsigned can be bit-shifted by signed and vice versa, but we need to
           // check that the basic type is an integer type.
           isBitShift = true;
           if (!IsInteger(left->getBasicType()) || !IsInteger(right->getBasicType()))
           {
               return false;
           }
           break;
       case EOpBitwiseAnd:
       case EOpBitwiseXor:
       case EOpBitwiseOr:
       case EOpBitwiseAndAssign:
       case EOpBitwiseXorAssign:
       case EOpBitwiseOrAssign:
           // It is enough to check the type of only one operand, since later it
           // is checked that the operand types match.
           if (!IsInteger(left->getBasicType()))
           {
               return false;
           }
           break;
       default:
           break;
   }

   ImplicitTypeConversion conversion = GetConversion(left->getBasicType(), right->getBasicType());

   // Implicit type casting only supported for GL shaders
   if (!isBitShift && conversion != ImplicitTypeConversion::Same &&
       (!IsDesktopGLSpec(mShaderSpec) || !IsValidImplicitConversion(conversion, op)))
   {
       return false;
   }

   // Check that:
   // 1. Type sizes match exactly on ops that require that.
   // 2. Restrictions for structs that contain arrays or samplers are respected.
   // 3. Arithmetic op type dimensionality restrictions for ops other than multiply are respected.
   switch (op)
   {
       case EOpAssign:
       case EOpInitialize:
       case EOpEqual:
       case EOpNotEqual:
           // ESSL 1.00 sections 5.7, 5.8, 5.9
           if (mShaderVersion < 300 && left->getType().isStructureContainingArrays())
           {
               error(loc, "undefined operation for structs containing arrays",
                     GetOperatorString(op));
               return false;
           }
           // Samplers as l-values are disallowed also in ESSL 3.00, see section 4.1.7,
           // we interpret the spec so that this extends to structs containing samplers,
           // similarly to ESSL 1.00 spec.
           if ((mShaderVersion < 300 || op == EOpAssign || op == EOpInitialize) &&
               left->getType().isStructureContainingSamplers())
           {
               error(loc, "undefined operation for structs containing samplers",
                     GetOperatorString(op));
               return false;
           }

           if ((left->getNominalSize() != right->getNominalSize()) ||
               (left->getSecondarySize() != right->getSecondarySize()))
           {
               error(loc, "dimension mismatch", GetOperatorString(op));
               return false;
           }
           break;
       case EOpLessThan:
       case EOpGreaterThan:
       case EOpLessThanEqual:
       case EOpGreaterThanEqual:
           if (!left->isScalar() || !right->isScalar())
           {
               error(loc, "comparison operator only defined for scalars", GetOperatorString(op));
               return false;
           }
           break;
       case EOpAdd:
       case EOpSub:
       case EOpDiv:
       case EOpIMod:
       case EOpBitShiftLeft:
       case EOpBitShiftRight:
       case EOpBitwiseAnd:
       case EOpBitwiseXor:
       case EOpBitwiseOr:
       case EOpAddAssign:
       case EOpSubAssign:
       case EOpDivAssign:
       case EOpIModAssign:
       case EOpBitShiftLeftAssign:
       case EOpBitShiftRightAssign:
       case EOpBitwiseAndAssign:
       case EOpBitwiseXorAssign:
       case EOpBitwiseOrAssign:
           if ((left->isMatrix() && right->isVector()) || (left->isVector() && right->isMatrix()))
           {
               return false;
           }

           // Are the sizes compatible?
           if (left->getNominalSize() != right->getNominalSize() ||
               left->getSecondarySize() != right->getSecondarySize())
           {
               // If the nominal sizes of operands do not match:
               // One of them must be a scalar.
               if (!left->isScalar() && !right->isScalar())
                   return false;

               // In the case of compound assignment other than multiply-assign,
               // the right side needs to be a scalar. Otherwise a vector/matrix
               // would be assigned to a scalar. A scalar can't be shifted by a
               // vector either.
               if (!right->isScalar() &&
                   (IsAssignment(op) || op == EOpBitShiftLeft || op == EOpBitShiftRight))
                   return false;
           }
           break;
       default:
           break;
   }

   return true;
}

bool TParseContext::isMultiplicationTypeCombinationValid(TOperator op,
                                                        const TType &left,
                                                        const TType &right)
{
   switch (op)
   {
       case EOpMul:
       case EOpMulAssign:
           return left.getNominalSize() == right.getNominalSize() &&
                  left.getSecondarySize() == right.getSecondarySize();
       case EOpVectorTimesScalar:
           return true;
       case EOpVectorTimesScalarAssign:
           ASSERT(!left.isMatrix() && !right.isMatrix());
           return left.isVector() && !right.isVector();
       case EOpVectorTimesMatrix:
           return left.getNominalSize() == right.getRows();
       case EOpVectorTimesMatrixAssign:
           ASSERT(!left.isMatrix() && right.isMatrix());
           return left.isVector() && left.getNominalSize() == right.getRows() &&
                  left.getNominalSize() == right.getCols();
       case EOpMatrixTimesVector:
           return left.getCols() == right.getNominalSize();
       case EOpMatrixTimesScalar:
           return true;
       case EOpMatrixTimesScalarAssign:
           ASSERT(left.isMatrix() && !right.isMatrix());
           return !right.isVector();
       case EOpMatrixTimesMatrix:
           return left.getCols() == right.getRows();
       case EOpMatrixTimesMatrixAssign:
           ASSERT(left.isMatrix() && right.isMatrix());
           // We need to check two things:
           // 1. The matrix multiplication step is valid.
           // 2. The result will have the same number of columns as the lvalue.
           return left.getCols() == right.getRows() && left.getCols() == right.getCols();

       default:
           UNREACHABLE();
           return false;
   }
}

TIntermTyped *TParseContext::addBinaryMathInternal(TOperator op,
                                                  TIntermTyped *left,
                                                  TIntermTyped *right,
                                                  const TSourceLoc &loc)
{
   if (!binaryOpCommonCheck(op, left, right, loc))
       return nullptr;

   switch (op)
   {
       case EOpEqual:
       case EOpNotEqual:
       case EOpLessThan:
       case EOpGreaterThan:
       case EOpLessThanEqual:
       case EOpGreaterThanEqual:
           break;
       case EOpLogicalOr:
       case EOpLogicalXor:
       case EOpLogicalAnd:
           ASSERT(!left->isArray() && !right->isArray() && !left->getType().getStruct() &&
                  !right->getType().getStruct());
           if (left->getBasicType() != EbtBool || !left->isScalar() || !right->isScalar())
           {
               return nullptr;
           }
           // Basic types matching should have been already checked.
           ASSERT(right->getBasicType() == EbtBool);
           break;
       case EOpAdd:
       case EOpSub:
       case EOpDiv:
       case EOpMul:
           ASSERT(!left->isArray() && !right->isArray() && !left->getType().getStruct() &&
                  !right->getType().getStruct());
           if (left->getBasicType() == EbtBool)
           {
               return nullptr;
           }
           break;
       case EOpIMod:
           ASSERT(!left->isArray() && !right->isArray() && !left->getType().getStruct() &&
                  !right->getType().getStruct());
           // Note that this is only for the % operator, not for mod()
           if (left->getBasicType() == EbtBool || left->getBasicType() == EbtFloat)
           {
               return nullptr;
           }
           break;
       default:
           break;
   }

   if (op == EOpMul)
   {
       op = TIntermBinary::GetMulOpBasedOnOperands(left->getType(), right->getType());
       if (!isMultiplicationTypeCombinationValid(op, left->getType(), right->getType()))
       {
           return nullptr;
       }
   }

   TIntermBinary *node = new TIntermBinary(op, left, right);
   ASSERT(op != EOpAssign);
   markStaticReadIfSymbol(left);
   markStaticReadIfSymbol(right);
   node->setLine(loc);
   return expressionOrFoldedResult(node);
}

TIntermTyped *TParseContext::addBinaryMath(TOperator op,
                                          TIntermTyped *left,
                                          TIntermTyped *right,
                                          const TSourceLoc &loc)
{
   TIntermTyped *node = addBinaryMathInternal(op, left, right, loc);
   if (node == 0)
   {
       binaryOpError(loc, GetOperatorString(op), left->getType(), right->getType());
       return left;
   }
   return node;
}

TIntermTyped *TParseContext::addBinaryMathBooleanResult(TOperator op,
                                                       TIntermTyped *left,
                                                       TIntermTyped *right,
                                                       const TSourceLoc &loc)
{
   TIntermTyped *node = addBinaryMathInternal(op, left, right, loc);
   if (node == nullptr)
   {
       binaryOpError(loc, GetOperatorString(op), left->getType(), right->getType());
       node = CreateBoolNode(false);
       node->setLine(loc);
   }
   return node;
}

TIntermTyped *TParseContext::addAssign(TOperator op,
                                      TIntermTyped *left,
                                      TIntermTyped *right,
                                      const TSourceLoc &loc)
{
   checkCanBeLValue(loc, "assign", left);
   TIntermBinary *node = nullptr;
   if (binaryOpCommonCheck(op, left, right, loc))
   {
       TIntermBinary *lValue = left->getAsBinaryNode();
       if ((lValue != nullptr) &&
           (lValue->getOp() == EOpIndexIndirect || lValue->getOp() == EOpIndexDirect) &&
           IsTessellationControlShaderOutput(mShaderType, lValue->getLeft()->getQualifier()))
       {
           checkTCSOutVarIndexIsValid(lValue, loc);
       }

       if (op == EOpMulAssign)
       {
           op = TIntermBinary::GetMulAssignOpBasedOnOperands(left->getType(), right->getType());
           if (isMultiplicationTypeCombinationValid(op, left->getType(), right->getType()))
           {
               node = new TIntermBinary(op, left, right);
           }
       }
       else
       {
           node = new TIntermBinary(op, left, right);
       }
   }
   if (node == nullptr)
   {
       assignError(loc, "assign", left->getType(), right->getType());
       return left;
   }
   if (op != EOpAssign)
   {
       markStaticReadIfSymbol(left);
   }
   markStaticReadIfSymbol(right);
   node->setLine(loc);
   return node;
}

TIntermTyped *TParseContext::addComma(TIntermTyped *left,
                                     TIntermTyped *right,
                                     const TSourceLoc &loc)
{
   // WebGL2 section 5.26, the following results in an error:
   // "Sequence operator applied to void, arrays, or structs containing arrays"
   if (mShaderSpec == SH_WEBGL2_SPEC &&
       (left->isArray() || left->getBasicType() == EbtVoid ||
        left->getType().isStructureContainingArrays() || right->isArray() ||
        right->getBasicType() == EbtVoid || right->getType().isStructureContainingArrays()))
   {
       error(loc,
             "sequence operator is not allowed for void, arrays, or structs containing arrays",
             ",");
   }

   TIntermBinary *commaNode = TIntermBinary::CreateComma(left, right, mShaderVersion);
   markStaticReadIfSymbol(left);
   markStaticReadIfSymbol(right);
   commaNode->setLine(loc);

   return expressionOrFoldedResult(commaNode);
}

TIntermBranch *TParseContext::addBranch(TOperator op, const TSourceLoc &loc)
{
   switch (op)
   {
       case EOpContinue:
           if (mLoopNestingLevel <= 0)
           {
               error(loc, "continue statement only allowed in loops", "");
           }
           break;
       case EOpBreak:
           if (mLoopNestingLevel <= 0 && mSwitchNestingLevel <= 0)
           {
               error(loc, "break statement only allowed in loops and switch statements", "");
           }
           break;
       case EOpReturn:
           if (mCurrentFunctionType->getBasicType() != EbtVoid)
           {
               error(loc, "non-void function must return a value", "return");
           }
           if (mDeclaringMain)
           {
               errorIfPLSDeclared(loc, PLSIllegalOperations::ReturnFromMain);
           }
           break;
       case EOpKill:
           if (mShaderType != GL_FRAGMENT_SHADER)
           {
               error(loc, "discard supported in fragment shaders only", "discard");
           }
           else
           {
               errorIfPLSDeclared(loc, PLSIllegalOperations::Discard);
           }
           mHasDiscard = true;
           break;
       default:
           UNREACHABLE();
           break;
   }
   return addBranch(op, nullptr, loc);
}

TIntermBranch *TParseContext::addBranch(TOperator op,
                                       TIntermTyped *expression,
                                       const TSourceLoc &loc)
{
   if (expression != nullptr)
   {
       markStaticReadIfSymbol(expression);
       ASSERT(op == EOpReturn);
       mFunctionReturnsValue = true;
       if (mCurrentFunctionType->getBasicType() == EbtVoid)
       {
           error(loc, "void function cannot return a value", "return");
       }
       else if (*mCurrentFunctionType != expression->getType())
       {
           error(loc, "function return is not matching type:", "return");
       }
   }
   TIntermBranch *node = new TIntermBranch(op, expression);
   node->setLine(loc);
   return node;
}

void TParseContext::appendStatement(TIntermBlock *block, TIntermNode *statement)
{
   if (statement != nullptr)
   {
       markStaticReadIfSymbol(statement);
       block->appendStatement(statement);
   }
}

void TParseContext::checkTextureGather(TIntermAggregate *functionCall)
{
   const TOperator op    = functionCall->getOp();
   const TFunction *func = functionCall->getFunction();
   if (BuiltInGroup::IsTextureGather(op))
   {
       bool isTextureGatherOffsetOrOffsets =
           BuiltInGroup::IsTextureGatherOffset(op) || BuiltInGroup::IsTextureGatherOffsets(op);
       TIntermNode *componentNode = nullptr;
       TIntermSequence *arguments = functionCall->getSequence();
       ASSERT(arguments->size() >= 2u && arguments->size() <= 4u);
       const TIntermTyped *sampler = arguments->front()->getAsTyped();
       ASSERT(sampler != nullptr);
       switch (sampler->getBasicType())
       {
           case EbtSampler2D:
           case EbtISampler2D:
           case EbtUSampler2D:
           case EbtSampler2DArray:
           case EbtISampler2DArray:
           case EbtUSampler2DArray:
               if ((!isTextureGatherOffsetOrOffsets && arguments->size() == 3u) ||
                   (isTextureGatherOffsetOrOffsets && arguments->size() == 4u))
               {
                   componentNode = arguments->back();
               }
               break;
           case EbtSamplerCube:
           case EbtISamplerCube:
           case EbtUSamplerCube:
           case EbtSamplerCubeArray:
           case EbtISamplerCubeArray:
           case EbtUSamplerCubeArray:
               ASSERT(!isTextureGatherOffsetOrOffsets);
               if (arguments->size() == 3u)
               {
                   componentNode = arguments->back();
               }
               break;
           case EbtSampler2DShadow:
           case EbtSampler2DArrayShadow:
           case EbtSamplerCubeShadow:
           case EbtSamplerCubeArrayShadow:
               break;
           default:
               UNREACHABLE();
               break;
       }
       if (componentNode)
       {
           const TIntermConstantUnion *componentConstantUnion =
               componentNode->getAsConstantUnion();
           if (componentNode->getAsTyped()->getQualifier() != EvqConst || !componentConstantUnion)
           {
               error(functionCall->getLine(), "Texture component must be a constant expression",
                     func->name());
           }
           else
           {
               int component = componentConstantUnion->getIConst(0);
               if (component < 0 || component > 3)
               {
                   error(functionCall->getLine(), "Component must be in the range [0;3]",
                         func->name());
               }
           }
       }
   }
}

void TParseContext::checkTextureOffset(TIntermAggregate *functionCall)
{
   const TOperator op         = functionCall->getOp();
   const TFunction *func      = functionCall->getFunction();
   TIntermNode *offset        = nullptr;
   TIntermSequence *arguments = functionCall->getSequence();

   if (BuiltInGroup::IsTextureOffsetNoBias(op) || BuiltInGroup::IsTextureGatherOffsetNoComp(op) ||
       BuiltInGroup::IsTextureGatherOffsetsNoComp(op))
   {
       offset = arguments->back();
   }
   else if (BuiltInGroup::IsTextureOffsetBias(op) || BuiltInGroup::IsTextureGatherOffsetComp(op) ||
            BuiltInGroup::IsTextureGatherOffsetsComp(op))
   {
       // A bias or comp parameter follows the offset parameter.
       ASSERT(arguments->size() >= 3);
       offset = (*arguments)[2];
   }

   // If not one of the above built-ins, there's nothing to do here.
   if (offset == nullptr)
   {
       return;
   }

   bool isTextureGatherOffset             = BuiltInGroup::IsTextureGatherOffset(op);
   bool isTextureGatherOffsets            = BuiltInGroup::IsTextureGatherOffsets(op);
   bool useTextureGatherOffsetConstraints = isTextureGatherOffset || isTextureGatherOffsets;

   int minOffsetValue =
       useTextureGatherOffsetConstraints ? mMinProgramTextureGatherOffset : mMinProgramTexelOffset;
   int maxOffsetValue =
       useTextureGatherOffsetConstraints ? mMaxProgramTextureGatherOffset : mMaxProgramTexelOffset;

   if (isTextureGatherOffsets)
   {
       // If textureGatherOffsets, the offsets parameter is an array, which is expected as an
       // aggregate constructor node or as a symbol node with a constant value.
       TIntermAggregate *offsetAggregate = offset->getAsAggregate();
       TIntermSymbol *offsetSymbol       = offset->getAsSymbolNode();

       const TConstantUnion *offsetValues = offsetAggregate ? offsetAggregate->getConstantValue()
                                            : offsetSymbol  ? offsetSymbol->getConstantValue()
                                                            : nullptr;

       if (offsetValues == nullptr)
       {
           error(functionCall->getLine(), "Texture offsets must be a constant expression",
                 func->name());
           return;
       }

       constexpr unsigned int kOffsetsCount = 4;
       const TType &offsetType =
           offsetAggregate != nullptr ? offsetAggregate->getType() : offsetSymbol->getType();
       if (offsetType.getNumArraySizes() != 1 || offsetType.getArraySizes()[0] != kOffsetsCount)
       {
           error(functionCall->getLine(), "Texture offsets must be an array of 4 elements",
                 func->name());
           return;
       }

       size_t size = offsetType.getObjectSize() / kOffsetsCount;
       for (unsigned int i = 0; i < kOffsetsCount; ++i)
       {
           checkSingleTextureOffset(offset->getLine(), &offsetValues[i * size], size,
                                    minOffsetValue, maxOffsetValue);
       }
   }
   else
   {
       // If textureOffset or textureGatherOffset, the offset is expected to be found as a constant
       // union.
       TIntermConstantUnion *offsetConstantUnion = offset->getAsConstantUnion();

       // ES3.2 or ES3.1's EXT_gpu_shader5 allow non-const offsets to be passed to
       // textureGatherOffset.
       bool textureGatherOffsetMustBeConst =
           mShaderVersion <= 310 && !isExtensionEnabled(TExtension::EXT_gpu_shader5);

       bool isOffsetConst =
           offset->getAsTyped()->getQualifier() == EvqConst && offsetConstantUnion != nullptr;
       bool offsetMustBeConst = !isTextureGatherOffset || textureGatherOffsetMustBeConst;

       if (!isOffsetConst && offsetMustBeConst)
       {
           error(functionCall->getLine(), "Texture offset must be a constant expression",
                 func->name());
           return;
       }

       // We cannot verify non-constant offsets to textureGatherOffset.
       if (offsetConstantUnion == nullptr)
       {
           ASSERT(!offsetMustBeConst);
           return;
       }

       size_t size                  = offsetConstantUnion->getType().getObjectSize();
       const TConstantUnion *values = offsetConstantUnion->getConstantValue();
       checkSingleTextureOffset(offset->getLine(), values, size, minOffsetValue, maxOffsetValue);
   }
}

void TParseContext::checkSingleTextureOffset(const TSourceLoc &line,
                                            const TConstantUnion *values,
                                            size_t size,
                                            int minOffsetValue,
                                            int maxOffsetValue)
{
   for (size_t i = 0u; i < size; ++i)
   {
       ASSERT(values[i].getType() == EbtInt);
       int offsetValue = values[i].getIConst();
       if (offsetValue > maxOffsetValue || offsetValue < minOffsetValue)
       {
           std::stringstream tokenStream = sh::InitializeStream<std::stringstream>();
           tokenStream << offsetValue;
           std::string token = tokenStream.str();
           error(line, "Texture offset value out of valid range", token.c_str());
       }
   }
}

void TParseContext::checkInterpolationFS(TIntermAggregate *functionCall)
{
   const TFunction *func = functionCall->getFunction();
   if (!BuiltInGroup::IsInterpolationFS(functionCall->getOp()))
   {
       return;
   }

   TIntermTyped *arg0 = nullptr;

   if (functionCall->getAsAggregate())
   {
       const TIntermSequence *argp = functionCall->getSequence();
       if (argp->size() > 0)
           arg0 = (*argp)[0]->getAsTyped();
   }
   else
   {
       assert(functionCall->getAsUnaryNode());
       arg0 = functionCall->getAsUnaryNode()->getOperand();
   }

   // Make sure the first argument is an interpolant, or an array element of an interpolant
   if (!IsVaryingIn(arg0->getType().getQualifier()))
   {
       // It might still be an array element.
       const TIntermTyped *base = FindLValueBase(arg0);

       if (base == nullptr || (!IsVaryingIn(base->getType().getQualifier())))
           error(arg0->getLine(),
                 "first argument must be an interpolant, or interpolant-array element",
                 func->name());
   }
}

void TParseContext::checkAtomicMemoryBuiltinFunctions(TIntermAggregate *functionCall)
{
   const TFunction *func = functionCall->getFunction();
   if (BuiltInGroup::IsAtomicMemory(functionCall->getOp()))
   {
       TIntermSequence *arguments = functionCall->getSequence();
       TIntermTyped *memNode      = (*arguments)[0]->getAsTyped();

       if (IsBufferOrSharedVariable(memNode))
       {
           return;
       }

       while (memNode->getAsBinaryNode() || memNode->getAsSwizzleNode())
       {
           // Child 0 is "left" if binary, and the expression being swizzled if swizzle.
           // Note: we don't need to check that the binary operation is one of EOp*Index*, as any
           // other operation will result in a temp value which cannot be passed to this
           // out/inout parameter anyway.
           memNode = memNode->getChildNode(0)->getAsTyped();
           if (IsBufferOrSharedVariable(memNode))
           {
               return;
           }
       }

       error(memNode->getLine(),
             "The value passed to the mem argument of an atomic memory function does not "
             "correspond to a buffer or shared variable.",
             func->name());
   }
}

// GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
void TParseContext::checkImageMemoryAccessForBuiltinFunctions(TIntermAggregate *functionCall)
{
   const TOperator op = functionCall->getOp();

   if (BuiltInGroup::IsImage(op))
   {
       TIntermSequence *arguments = functionCall->getSequence();
       TIntermTyped *imageNode    = (*arguments)[0]->getAsTyped();

       const TMemoryQualifier &memoryQualifier = imageNode->getMemoryQualifier();

       if (BuiltInGroup::IsImageStore(op))
       {
           if (memoryQualifier.readonly)
           {
               error(imageNode->getLine(),
                     "'imageStore' cannot be used with images qualified as 'readonly'",
                     GetImageArgumentToken(imageNode));
           }
       }
       else if (BuiltInGroup::IsImageLoad(op))
       {
           if (memoryQualifier.writeonly)
           {
               error(imageNode->getLine(),
                     "'imageLoad' cannot be used with images qualified as 'writeonly'",
                     GetImageArgumentToken(imageNode));
           }
       }
       else if (BuiltInGroup::IsImageAtomic(op))
       {
           if (memoryQualifier.readonly)
           {
               error(imageNode->getLine(),
                     "'imageAtomic' cannot be used with images qualified as 'readonly'",
                     GetImageArgumentToken(imageNode));
           }
           if (memoryQualifier.writeonly)
           {
               error(imageNode->getLine(),
                     "'imageAtomic' cannot be used with images qualified as 'writeonly'",
                     GetImageArgumentToken(imageNode));
           }
       }
   }
}

// GLSL ES 3.10 Revision 4, 13.51 Matching of Memory Qualifiers in Function Parameters
void TParseContext::checkImageMemoryAccessForUserDefinedFunctions(
   const TFunction *functionDefinition,
   const TIntermAggregate *functionCall)
{
   ASSERT(functionCall->getOp() == EOpCallFunctionInAST);

   const TIntermSequence &arguments = *functionCall->getSequence();

   ASSERT(functionDefinition->getParamCount() == arguments.size());

   for (size_t i = 0; i < arguments.size(); ++i)
   {
       TIntermTyped *typedArgument        = arguments[i]->getAsTyped();
       const TType &functionArgumentType  = typedArgument->getType();
       const TType &functionParameterType = functionDefinition->getParam(i)->getType();
       ASSERT(functionArgumentType.getBasicType() == functionParameterType.getBasicType());

       if (IsImage(functionArgumentType.getBasicType()))
       {
           const TMemoryQualifier &functionArgumentMemoryQualifier =
               functionArgumentType.getMemoryQualifier();
           const TMemoryQualifier &functionParameterMemoryQualifier =
               functionParameterType.getMemoryQualifier();
           if (functionArgumentMemoryQualifier.readonly &&
               !functionParameterMemoryQualifier.readonly)
           {
               error(functionCall->getLine(),
                     "Function call discards the 'readonly' qualifier from image",
                     GetImageArgumentToken(typedArgument));
           }

           if (functionArgumentMemoryQualifier.writeonly &&
               !functionParameterMemoryQualifier.writeonly)
           {
               error(functionCall->getLine(),
                     "Function call discards the 'writeonly' qualifier from image",
                     GetImageArgumentToken(typedArgument));
           }

           if (functionArgumentMemoryQualifier.coherent &&
               !functionParameterMemoryQualifier.coherent)
           {
               error(functionCall->getLine(),
                     "Function call discards the 'coherent' qualifier from image",
                     GetImageArgumentToken(typedArgument));
           }

           if (functionArgumentMemoryQualifier.volatileQualifier &&
               !functionParameterMemoryQualifier.volatileQualifier)
           {
               error(functionCall->getLine(),
                     "Function call discards the 'volatile' qualifier from image",
                     GetImageArgumentToken(typedArgument));
           }
       }
   }
}

TIntermTyped *TParseContext::addFunctionCallOrMethod(TFunctionLookup *fnCall, const TSourceLoc &loc)
{
   if (fnCall->thisNode() != nullptr)
   {
       return addMethod(fnCall, loc);
   }
   if (fnCall->isConstructor())
   {
       return addConstructor(fnCall, loc);
   }
   return addNonConstructorFunctionCall(fnCall, loc);
}

TIntermTyped *TParseContext::addMethod(TFunctionLookup *fnCall, const TSourceLoc &loc)
{
   TIntermTyped *thisNode = fnCall->thisNode();
   // It's possible for the name pointer in the TFunction to be null in case it gets parsed as
   // a constructor. But such a TFunction can't reach here, since the lexer goes into FIELDS
   // mode after a dot, which makes type identifiers to be parsed as FIELD_SELECTION instead.
   // So accessing fnCall->name() below is safe.
   if (fnCall->name() != "length")
   {
       error(loc, "invalid method", fnCall->name());
   }
   else if (!fnCall->arguments().empty())
   {
       error(loc, "method takes no parameters", "length");
   }
   else if (!thisNode->isArray())
   {
       error(loc, "length can only be called on arrays", "length");
   }
   else if (thisNode->getQualifier() == EvqPerVertexIn &&
            mGeometryShaderInputPrimitiveType == EptUndefined)
   {
       ASSERT(mShaderType == GL_GEOMETRY_SHADER_EXT);
       error(loc, "missing input primitive declaration before calling length on gl_in", "length");
   }
   else
   {
       TIntermUnary *node = new TIntermUnary(EOpArrayLength, thisNode, nullptr);
       markStaticReadIfSymbol(thisNode);
       node->setLine(loc);
       return node->fold(mDiagnostics);
   }
   return CreateZeroNode(TType(EbtInt, EbpUndefined, EvqConst));
}

TIntermTyped *TParseContext::addNonConstructorFunctionCall(TFunctionLookup *fnCall,
                                                          const TSourceLoc &loc)
{
   // First check whether the function has been hidden by a variable name or struct typename by
   // using the symbol looked up in the lexical phase. If the function is not hidden, look for one
   // with a matching argument list.
   if (fnCall->symbol() != nullptr && !fnCall->symbol()->isFunction())
   {
       error(loc, "function name expected", fnCall->name());
   }
   else
   {
       // There are no inner functions, so it's enough to look for user-defined functions in the
       // global scope.
       const TSymbol *symbol = symbolTable.findGlobal(fnCall->getMangledName());

       if (symbol == nullptr && IsDesktopGLSpec(mShaderSpec))
       {
           // If using Desktop GL spec, need to check for implicit conversion
           symbol = symbolTable.findGlobalWithConversion(
               fnCall->getMangledNamesForImplicitConversions());
       }

       if (symbol != nullptr)
       {
           // A user-defined function - could be an overloaded built-in as well.
           ASSERT(symbol->symbolType() == SymbolType::UserDefined);
           const TFunction *fnCandidate = static_cast<const TFunction *>(symbol);
           TIntermAggregate *callNode =
               TIntermAggregate::CreateFunctionCall(*fnCandidate, &fnCall->arguments());
           callNode->setLine(loc);
           checkImageMemoryAccessForUserDefinedFunctions(fnCandidate, callNode);
           functionCallRValueLValueErrorCheck(fnCandidate, callNode);
           return callNode;
       }

       symbol = symbolTable.findBuiltIn(fnCall->getMangledName(), mShaderVersion);

       if (symbol == nullptr && IsDesktopGLSpec(mShaderSpec))
       {
           // If using Desktop GL spec, need to check for implicit conversion
           symbol = symbolTable.findBuiltInWithConversion(
               fnCall->getMangledNamesForImplicitConversions(), mShaderVersion);
       }

       if (symbol != nullptr)
       {
           // A built-in function.
           ASSERT(symbol->symbolType() == SymbolType::BuiltIn);
           const TFunction *fnCandidate = static_cast<const TFunction *>(symbol);

           if (!fnCandidate->extensions().empty() &&
               fnCandidate->extensions()[0] != TExtension::UNDEFINED)
           {
               checkCanUseOneOfExtensions(loc, fnCandidate->extensions());
           }

           // All function calls are mapped to a built-in operation.
           TOperator op = fnCandidate->getBuiltInOp();
           if (BuiltInGroup::IsMath(op) && fnCandidate->getParamCount() == 1)
           {
               // Treat it like a built-in unary operator.
               TIntermNode *unaryParamNode = fnCall->arguments().front();
               TIntermTyped *callNode =
                   createUnaryMath(op, unaryParamNode->getAsTyped(), loc, fnCandidate);
               ASSERT(callNode != nullptr);
               return callNode;
           }

           TIntermAggregate *callNode =
               TIntermAggregate::CreateBuiltInFunctionCall(*fnCandidate, &fnCall->arguments());
           callNode->setLine(loc);

           checkAtomicMemoryBuiltinFunctions(callNode);
           checkTextureOffset(callNode);
           checkTextureGather(callNode);
           checkInterpolationFS(callNode);
           checkImageMemoryAccessForBuiltinFunctions(callNode);

           // Some built-in functions have out parameters too.
           functionCallRValueLValueErrorCheck(fnCandidate, callNode);

           // See if we can constant fold a built-in. Note that this may be possible
           // even if it is not const-qualified.
           return callNode->fold(mDiagnostics);
       }
       else
       {
           error(loc, "no matching overloaded function found", fnCall->name());
       }
   }

   // Error message was already written. Put on an unused node for error recovery.
   return CreateZeroNode(TType(EbtFloat, EbpMedium, EvqConst));
}

TIntermTyped *TParseContext::addTernarySelection(TIntermTyped *cond,
                                                TIntermTyped *trueExpression,
                                                TIntermTyped *falseExpression,
                                                const TSourceLoc &loc)
{
   if (!checkIsScalarBool(loc, cond))
   {
       return falseExpression;
   }

   if (trueExpression->getType() != falseExpression->getType())
   {
       TInfoSinkBase reasonStream;
       reasonStream << "mismatching ternary operator operand types '" << trueExpression->getType()
                    << " and '" << falseExpression->getType() << "'";
       error(loc, reasonStream.c_str(), "?:");
       return falseExpression;
   }
   if (IsOpaqueType(trueExpression->getBasicType()))
   {
       // ESSL 1.00 section 4.1.7
       // ESSL 3.00.6 section 4.1.7
       // Opaque/sampler types are not allowed in most types of expressions, including ternary.
       // Note that structs containing opaque types don't need to be checked as structs are
       // forbidden below.
       error(loc, "ternary operator is not allowed for opaque types", "?:");
       return falseExpression;
   }

   if (cond->getMemoryQualifier().writeonly || trueExpression->getMemoryQualifier().writeonly ||
       falseExpression->getMemoryQualifier().writeonly)
   {
       error(loc, "ternary operator is not allowed for variables with writeonly", "?:");
       return falseExpression;
   }

   // ESSL 1.00.17 sections 5.2 and 5.7:
   // Ternary operator is not among the operators allowed for structures/arrays.
   // ESSL 3.00.6 section 5.7:
   // Ternary operator support is optional for arrays. No certainty that it works across all
   // devices with struct either, so we err on the side of caution here. TODO (oetuaho@nvidia.com):
   // Would be nice to make the spec and implementation agree completely here.
   if (trueExpression->isArray() || trueExpression->getBasicType() == EbtStruct)
   {
       error(loc, "ternary operator is not allowed for structures or arrays", "?:");
       return falseExpression;
   }
   if (trueExpression->getBasicType() == EbtInterfaceBlock)
   {
       error(loc, "ternary operator is not allowed for interface blocks", "?:");
       return falseExpression;
   }

   // WebGL2 section 5.26, the following results in an error:
   // "Ternary operator applied to void, arrays, or structs containing arrays"
   if (mShaderSpec == SH_WEBGL2_SPEC && trueExpression->getBasicType() == EbtVoid)
   {
       error(loc, "ternary operator is not allowed for void", "?:");
       return falseExpression;
   }

   TIntermTernary *node = new TIntermTernary(cond, trueExpression, falseExpression);
   markStaticReadIfSymbol(cond);
   markStaticReadIfSymbol(trueExpression);
   markStaticReadIfSymbol(falseExpression);
   node->setLine(loc);
   return expressionOrFoldedResult(node);
}

//
// Parse an array of strings using yyparse.
//
// Returns 0 for success.
//
int PaParseStrings(size_t count,
                  const char *const string[],
                  const int length[],
                  TParseContext *context)
{
   if ((count == 0) || (string == nullptr))
       return 1;

   if (glslang_initialize(context))
       return 1;

   int error = glslang_scan(count, string, length, context);
   if (!error)
       error = glslang_parse(context);

   glslang_finalize(context);

   return (error == 0) && (context->numErrors() == 0) ? 0 : 1;
}

}  // namespace sh