/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp

Bug Summary

File:	root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp
Warning:	line 371, column 29 The left operand of '!=' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ParseContext.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +sse2 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/gfx/angle/targets/translator -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/gfx/angle/targets/translator -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -D ANGLE_PLATFORM_EXPORT= -D __NDK_FPABI__= -D ANGLE_SKIP_DXGI_1_2_CHECK -D ANGLE_ENABLE_KEYEDMUTEX -D ANGLE_TRANSLATOR_ESSL_ONLY -D ANGLE_DISABLE_POOL_ALLOC -D ANGLE_ENABLE_APPLE_WORKAROUNDS -D ANGLE_ENABLE_ESSL -D ANGLE_ENABLE_GLSL -D ANGLE_ENABLE_HLSL -D ANGLE_ENABLE_SHARE_CONTEXT_LOCK=1 -D ANGLE_VMA_VERSION=2003000 -D CR_CLANG_REVISION="llvmorg-16-init-6578-g0d30e92f-2" -D DYNAMIC_ANNOTATIONS_ENABLED=0 -D NOMINMAX -D UNICODE -D WINVER=0x0A00 -D _ATL_NO_OPENGL -D _CRT_NONSTDC_NO_WARNINGS -D _CRT_RAND_S -D _CRT_SECURE_NO_DEPRECATE -D _HAS_EXCEPTIONS=0 -D _SCL_SECURE_NO_DEPRECATE -D _SECURE_ATL -D _UNICODE -D _WINSOCK_DEPRECATED_NO_WARNINGS -I /root/firefox-clang/gfx/angle/targets/translator -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/gfx/angle/targets/translator -I /root/firefox-clang/gfx/angle/checkout/include -I /root/firefox-clang/gfx/angle/checkout/src -I /root/firefox-clang/gfx/angle/checkout/src/common/third_party/base -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -Wno-final-dtor-non-final-class -Wno-implicit-const-int-float-conversion -Wno-range-loop-construct -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ /root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp
1//
2// Copyright 2002 The ANGLE Project Authors. All rights reserved.
3// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//

7#include "compiler/translator/ParseContext.h"

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

12#include "common/mathutil.h"
13#include "common/utilities.h"
14#include "compiler/preprocessor/SourceLocation.h"
15#include "compiler/translator/Declarator.h"
16#include "compiler/translator/StaticType.h"
17#include "compiler/translator/ValidateGlobalInitializer.h"
18#include "compiler/translator/ValidateSwitch.h"
19#include "compiler/translator/glslang.h"
20#include "compiler/translator/tree_util/IntermNode_util.h"
21#include "compiler/translator/util.h"

23namespace sh
24{

26///////////////////////////////////////////////////////////////////////
27//
28// Sub- vector and matrix fields
29//
30////////////////////////////////////////////////////////////////////////

32namespace
33{

35const int kWebGLMaxStructNesting = 4;

37bool ContainsSampler(const TStructure *structType);

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

  return false;
51}

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

63// Get a token from an image argument to use as an error message token.
64const char *GetImageArgumentToken(TIntermTyped *imageNode)
65{
  ASSERT(IsImage(imageNode->getBasicType()))(IsImage(imageNode->getBasicType()) ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 66, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 66 << "): " << "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";
79}

81bool CanSetDefaultPrecisionOnType(const TPublicType &type)
82{
  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;
98}

100// Map input primitive types to input array sizes in a geometry shader.
101GLuint GetGeometryShaderInputArraySize(TLayoutPrimitiveType primitiveType)
102{
  switch (primitiveType)
  {
      case EptPoints:
          return 1u;
      case EptLines:
          return 2u;
      case EptTriangles:
          return 3u;
      case EptLinesAdjacency:
          return 4u;
      case EptTrianglesAdjacency:
          return 6u;
      default:
          UNREACHABLE()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 116, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 116 << ")"; } while (0);
          return 0u;
  }
119}

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

131TIntermTyped *FindLValueBase(TIntermTyped *node)
132{
  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);
149}

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

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

172// This tracks each binding point's current default offset for inheritance of subsequent
173// variables using the same binding, and keeps offsets unique and non overlapping.
174// See GLSL ES 3.1, section 4.4.6.
175class TParseContext::AtomicCounterBindingState
176{
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;
202};

204TParseContext::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)
271{}

273TParseContext::~TParseContext() {}

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

281bool TParseContext::parseVectorFields(const TSourceLoc &line,
                                    const ImmutableString &compString,
                                    int vecSize,
                                    TVector<int> *fieldOffsets)
285{
  ASSERT(fieldOffsets)(fieldOffsets ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 286, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 286 << "): " << "fieldOffsets"
));
4
←
'?' condition is true→
  size_t fieldCount = compString.length();
  if (fieldCount > 4u)
5
←
Assuming 'fieldCount' is <= 4→
6
←
Taking false branch→
  {
      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)
7
←
Assuming the condition is false→
8
←
Loop condition is false. Execution continues on line 361→
  {
      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)
9
←
Assuming the condition is true→
10
←
Loop condition is true.  Entering loop body→
14
←
The value 1 is assigned to 'i'→
15
←
Assuming the condition is true→
16
←
Loop condition is true.  Entering loop body→
  {
      if ((*fieldOffsets)[i] >= vecSize)
11
←
Assuming the condition is false→
12
←
Taking false branch→
17
←
Assuming the condition is false→
18
←
Taking false branch→
      {
          error(line, "vector field selection out of range", compString);
          return false;
      }

      if (i12.1
'i' is <= 0
1
'i' is > 0
 > 0)
13
←
Taking false branch→
19
←
Taking true branch→
      {
          if (fieldSet[i] != fieldSet[i - 1])
20
←
The left operand of '!=' is a garbage value
          {
              error(line, "illegal - vector component fields not from the same set", compString);
              return false;
          }
      }
  }

  return true;
380}

382///////////////////////////////////////////////////////////////////////
383//
384// Errors
385//
386////////////////////////////////////////////////////////////////////////

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

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

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

406void TParseContext::errorIfPLSDeclared(const TSourceLoc &loc, PLSIllegalOperations op)
407{
  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;
  }
435}

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

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

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

471//
472// Same error message for all places unary operations don't work.
473//
474void TParseContext::unaryOpError(const TSourceLoc &line, const char *op, const TType &operand)
475{
  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);
481}

483//
484// Same error message for all binary operations don't work.
485//
486void TParseContext::binaryOpError(const TSourceLoc &line,
                                const char *op,
                                const TType &left,
                                const TType &right)
490{
  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);
497}

499void TParseContext::checkPrecisionSpecified(const TSourceLoc &line,
                                          TPrecision precision,
                                          TBasicType type)
502{
  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()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 520, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 520 << ")"; } while (0);  // 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;
              }
      }
  }
531}

533void TParseContext::markStaticReadIfSymbol(TIntermNode *node)
534{
  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());
  }
561}

563// Both test and if necessary, spit out an error, to see if the node is really
564// an l-value that can be operated on this way.
565bool TParseContext::checkCanBeLValue(const TSourceLoc &line, const char *op, TIntermTyped *node)
566{
  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_SHADER0x8B30)
          {
              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_SHADER0x8B30)
          {
              message = "can't modify gl_ClipDistance in a fragment shader";
          }
          break;
      case EvqCullDistance:
          if (mShaderType == GL_FRAGMENT_SHADER0x8B30)
          {
              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)(binaryNode == nullptr && swizzleNode == nullptr ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 731, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 731 << "): " << "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)(symNode->variable().symbolType() != SymbolType::Empty ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 746, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 746 << "): " << "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;
759}

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

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

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

793// ESSL 3.00.5 sections 3.8 and 3.9.
794// If it starts "gl_" or contains two consecutive underscores, it's reserved.
795// Also checks for "webgl_" and "_webgl_" reserved identifiers if parsing a webgl shader.
796bool TParseContext::checkIsNotReserved(const TSourceLoc &line, const ImmutableString &identifier)
797{
  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;
845}

847// Make sure the argument types are correct for constructing a specific type.
848bool TParseContext::checkConstructorArguments(const TSourceLoc &line,
                                            const TIntermSequence &arguments,
                                            const TType &type)
851{
  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)(argTyped != nullptr ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 862, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 862 << "): " << "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())(!type.isUnsizedArray() ? static_cast<void>(0) : (!((::
gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ?
 static_cast<void>(0) : ::gl::priv::LogMessageVoidify()
 & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 885, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 885 << "): " << "!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)(argTyped != nullptr ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 945, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 945 << "): " << "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;
999}

1001// This function checks to see if a void variable has been declared and raise an error message for
1002// such a case
1003//
1004// returns true in case of an error
1005//
1006bool TParseContext::checkIsNonVoid(const TSourceLoc &line,
                                 const ImmutableString &identifier,
                                 const TBasicType &type)
1009{
  if (type == EbtVoid)
  {
      error(line, "illegal use of type 'void'", identifier);
      return false;
  }

  return true;
1017}

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

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

1041bool TParseContext::checkIsNotOpaqueType(const TSourceLoc &line,
                                       const TTypeSpecifierNonArray &pType,
                                       const char *reason)
1044{
  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;
1066}

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

1078void TParseContext::checkLocationIsNotSpecified(const TSourceLoc &location,
                                              const TLayoutQualifier &layoutQualifier)
1080{
  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");
  }
1091}

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

1103void TParseContext::checkOutParameterIsNotOpaqueType(const TSourceLoc &line,
                                                   TQualifier qualifier,
                                                   const TType &type)
1106{
  ASSERT(qualifier == EvqParamOut || qualifier == EvqParamInOut)(qualifier == EvqParamOut || qualifier == EvqParamInOut ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1107, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1107 << "): " << "qualifier == EvqParamOut || qualifier == EvqParamInOut"
));
  if (IsOpaqueType(type.getBasicType()))
  {
      error(line, "opaque types cannot be output parameters", type.getBasicString());
  }
1112}

1114// Do size checking for an array type's size.
1115unsigned int TParseContext::checkIsValidArraySize(const TSourceLoc &line, TIntermTyped *expr)
1116{
  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;
1169}

1171// See if this qualifier can be an array.
1172bool TParseContext::checkIsValidQualifierForArray(const TSourceLoc &line,
                                                const TPublicType &elementQualifier)
1174{
  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;
1185}

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

1201// Check for array-of-arrays being used as non-allowed shader inputs/outputs.
1202bool TParseContext::checkArrayOfArraysInOut(const TSourceLoc &line,
                                          const TPublicType &elementType,
                                          const TType &arrayType)
1205{
  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;
1228}

1230// Check if this qualified element type can be formed into an array. This is only called when array
1231// brackets are associated with an identifier in a declaration, like this:
1232//   float a[2];
1233// Similar checks are done in addFullySpecifiedType for array declarations where the array brackets
1234// are associated with the type, like this:
1235//   float[2] a;
1236bool TParseContext::checkIsValidTypeAndQualifierForArray(const TSourceLoc &indexLocation,
                                                       const TPublicType &elementType)
1238{
  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);
1264}

1266// Enforce non-initializer type/qualifier rules.
1267void TParseContext::checkCanBeDeclaredWithoutInitializer(const TSourceLoc &line,
                                                       const ImmutableString &identifier,
                                                       TType *type)
1270{
  ASSERT(type != nullptr)(type != nullptr ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1271, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1271 << "): " << "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_SHADER0x8E88 && mShaderType != GL_TESS_EVALUATION_SHADER0x8E87 &&
        mShaderType != GL_GEOMETRY_SHADER0x8DD9) ||
       (mShaderType == GL_GEOMETRY_SHADER0x8DD9 && 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);
          }
      }
  }
1310}

1312// Do some simple checks that are shared between all variable declarations,
1313// and update the symbol table.
1314//
1315// Returns true if declaring the variable succeeded.
1316//
1317bool TParseContext::declareVariable(const TSourceLoc &line,
                                  const ImmutableString &identifier,
                                  const TType *type,
                                  TVariable **variable)
1321{
  ASSERT((*variable) == nullptr)((*variable) == nullptr ? static_cast<void>(0) : (!((::
gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ?
 static_cast<void>(0) : ::gl::priv::LogMessageVoidify()
 & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1322, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1322 << "): " << "(*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 ||(type->getLayoutQualifier().index == -1 || (isExtensionEnabled
(TExtension::EXT_blend_func_extended) && mShaderType ==
 0x8B30 && mShaderVersion >= 300) ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1340, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1340 << "): " << "type->getLayoutQualifier().index == -1 || (isExtensionEnabled(TExtension::EXT_blend_func_extended) && mShaderType == GL_FRAGMENT_SHADER && mShaderVersion >= 300)"
))
         (isExtensionEnabled(TExtension::EXT_blend_func_extended) &&(type->getLayoutQualifier().index == -1 || (isExtensionEnabled
(TExtension::EXT_blend_func_extended) && mShaderType ==
 0x8B30 && mShaderVersion >= 300) ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1340, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1340 << "): " << "type->getLayoutQualifier().index == -1 || (isExtensionEnabled(TExtension::EXT_blend_func_extended) && mShaderType == GL_FRAGMENT_SHADER && mShaderVersion >= 300)"
))
          mShaderType == GL_FRAGMENT_SHADER && mShaderVersion >= 300))(type->getLayoutQualifier().index == -1 || (isExtensionEnabled
(TExtension::EXT_blend_func_extended) && mShaderType ==
 0x8B30 && mShaderVersion >= 300) ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1340, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1340 << "): " << "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;
1473}

1475void TParseContext::checkIsParameterQualifierValid(
  const TSourceLoc &line,
  const TTypeQualifierBuilder &typeQualifierBuilder,
  TType *type)
1479{
  // 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);
  }
1509}

1511template <size_t size>
1512bool TParseContext::checkCanUseOneOfExtensions(const TSourceLoc &line,
                                             const std::array<TExtension, size> &extensions)
1514{
  ASSERT(!extensions.empty())(!extensions.empty() ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1515, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1515 << "): " << "!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)(extIter->second == EBhEnable || extIter->second == EBhRequire
 ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1563, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1563 << "): " << "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;
1580}

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

1592bool TParseContext::checkCanUseExtension(const TSourceLoc &line, TExtension extension)
1593{
  ASSERT(extension != TExtension::UNDEFINED)(extension != TExtension::UNDEFINED ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1594, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1594 << "): " << "extension != TExtension::UNDEFINED"
));
  return checkCanUseOneOfExtensions(line, std::array<TExtension, 1u>{{extension}});
1596}

1598// ESSL 3.00.6 section 4.8 Empty Declarations: "The combinations of qualifiers that cause
1599// compile-time or link-time errors are the same whether or not the declaration is empty".
1600// This function implements all the checks that are done on qualifiers regardless of if the
1601// declaration is empty.
1602void TParseContext::declarationQualifierErrorCheck(const sh::TQualifier qualifier,
                                                 const sh::TLayoutQualifier &layoutQualifier,
                                                 const TSourceLoc &location)
1605{
  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);
  }
1670}

1672void TParseContext::atomicCounterQualifierErrorCheck(const TPublicType &publicType,
                                                   const TSourceLoc &location)
1674{
  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");
  }
1688}

1690void TParseContext::emptyDeclarationErrorCheck(const TType &type, const TSourceLoc &location)
1691{
  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);
  }
1703}

1705// These checks are done for all declarations that are non-empty. They're done for non-empty
1706// declarations starting a declarator list, and declarators that follow an empty declaration.
1707void TParseContext::nonEmptyDeclarationErrorCheck(const TPublicType &publicType,
                                                const TSourceLoc &identifierLocation)
1709{
  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_SHADER0x8B30)
      {
          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))(!IsValidWithPixelLocalStorage(layoutQualifier.imageInternalFormat
) ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1895, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1895 << "): " << "!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);
  }
1921}

1923void TParseContext::checkBindingIsValid(const TSourceLoc &identifierLocation, const TType &type)
1924{
  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()))(!IsOpaqueType(type.getBasicType()) ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 1956, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 1956 << "): " << "!IsOpaqueType(type.getBasicType())"
));
      checkBindingIsNotSpecified(identifierLocation, layoutQualifier.binding);
  }
1959}

1961void TParseContext::checkCanUseLayoutQualifier(const TSourceLoc &location)
1962{
  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");
  }
1971}

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

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

1986bool TParseContext::checkWorkGroupSizeIsNotSpecified(const TSourceLoc &location,
                                                   const TLayoutQualifier &layoutQualifier)
1988{
  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;
2003}

2005void TParseContext::checkInternalFormatIsNotSpecified(const TSourceLoc &location,
                                                    TLayoutImageInternalFormat internalFormat)
2007{
  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));
          }
      }
  }
2041}

2043void TParseContext::checkIndexIsNotSpecified(const TSourceLoc &location, int index)
2044{
  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");
  }
2052}

2054void TParseContext::checkBindingIsNotSpecified(const TSourceLoc &location, int binding)
2055{
  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");
      }
  }
2071}

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

2082void TParseContext::checkImageBindingIsValid(const TSourceLoc &location,
                                           int binding,
                                           int arrayTotalElementCount)
2085{
  // 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");
  }
2091}

2093void TParseContext::checkSamplerBindingIsValid(const TSourceLoc &location,
                                             int binding,
                                             int arrayTotalElementCount)
2096{
  // 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");
  }
2102}

2104void TParseContext::checkBlockBindingIsValid(const TSourceLoc &location,
                                           const TQualifier &qualifier,
                                           int binding,
                                           int arraySize)
2108{
  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");
      }
  }
2127}
2128void TParseContext::checkAtomicCounterBindingIsValid(const TSourceLoc &location, int binding)
2129{
  if (binding >= mMaxAtomicCounterBindings)
  {
      error(location, "atomic counter binding greater than gl_MaxAtomicCounterBindings",
            "binding");
  }
2135}

2137void TParseContext::checkPixelLocalStorageBindingIsValid(const TSourceLoc &location,
                                                       const TType &type)
2139{
  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();
      }
  }
2174}

2176void TParseContext::checkUniformLocationInRange(const TSourceLoc &location,
                                              int objectLocationCount,
                                              const TLayoutQualifier &layoutQualifier)
2179{
  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");
      }
  }
2190}

2192void TParseContext::checkAttributeLocationInRange(const TSourceLoc &location,
                                                int objectLocationCount,
                                                const TLayoutQualifier &layoutQualifier)
2195{
  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");
      }
  }
2206}

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

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

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

2238void TParseContext::checkNoncoherentIsNotSpecified(const TSourceLoc &location, bool noncoherent)
2239{
  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");
  }
2247}

2249void TParseContext::checkTCSOutVarIndexIsValid(TIntermBinary *binaryExpression,
                                             const TSourceLoc &location)
2251{
  ASSERT(binaryExpression->getOp() == EOpIndexIndirect ||(binaryExpression->getOp() == EOpIndexIndirect || binaryExpression
->getOp() == EOpIndexDirect ? static_cast<void>(0) :
 (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2253, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2253 << "): " << "binaryExpression->getOp() == EOpIndexIndirect || binaryExpression->getOp() == EOpIndexDirect"
))
         binaryExpression->getOp() == EOpIndexDirect)(binaryExpression->getOp() == EOpIndexIndirect || binaryExpression
->getOp() == EOpIndexDirect ? static_cast<void>(0) :
 (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2253, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2253 << "): " << "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",
            "[");
  }
2262}

2264void TParseContext::functionCallRValueLValueErrorCheck(const TFunction *fnCandidate,
                                                     TIntermAggregate *fnCall)
2266{
  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;
          }
      }
  }
2298}

2300void TParseContext::checkInvariantVariableQualifier(bool invariant,
                                                  const TQualifier qualifier,
                                                  const TSourceLoc &invariantLocation)
2303{
  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");
      }
  }
2322}

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

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

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

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

2364sh::WorkGroupSize TParseContext::getComputeShaderLocalSize() const
2365{
  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;
2379}

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

2390/////////////////////////////////////////////////////////////////////////////////
2391//
2392// Non-Errors.
2393//
2394/////////////////////////////////////////////////////////////////////////////////

2396const TVariable *TParseContext::getNamedVariable(const TSourceLoc &location,
                                               const ImmutableString &name,
                                               const TSymbol *symbol)
2399{
  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_SHADER0x91B9 && !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;
2439}

2441TIntermTyped *TParseContext::parseVariableIdentifier(const TSourceLoc &location,
                                                   const ImmutableString &name,
                                                   const TSymbol *symbol)
2444{
  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)(variableType.getBasicType() == EbtUInt ? static_cast<void
>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl
::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2473, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2473 << "): " << "variableType.getBasicType() == EbtUInt"
));
      ASSERT(variableType.getObjectSize() == 3)(variableType.getObjectSize() == 3 ? static_cast<void>(
0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2474, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2474 << "): " << "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)(symbolTable.getGlInVariableWithArraySize() != nullptr ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2483, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2483 << "): " << "symbolTable.getGlInVariableWithArraySize() != nullptr"
));
      node = new TIntermSymbol(symbolTable.getGlInVariableWithArraySize());
  }
  else
  {
      node = new TIntermSymbol(variable);
  }
  ASSERT(node != nullptr)(node != nullptr ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2490, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2490 << "): " << "node != nullptr"
));
  node->setLine(location);
  return node;
2493}

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

2511// Initializers show up in several places in the grammar.  Have one set of
2512// code to handle them here.
2513//
2514// Returns true on success.
2515bool TParseContext::executeInitializer(const TSourceLoc &line,
                                     const ImmutableString &identifier,
                                     TType *type,
                                     TIntermTyped *initializer,
                                     TIntermBinary **initNode)
2520{
  ASSERT(initNode != nullptr)(initNode != nullptr ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2521, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2521 << "): " << "initNode != nullptr"
));
  ASSERT(*initNode == nullptr)(*initNode == nullptr ? static_cast<void>(0) : (!((::gl
::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2522, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2522 << "): " << "*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)(*initNode == nullptr ? static_cast<void>(0) : (!((::gl
::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2609, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2609 << "): " << "*initNode == nullptr"
));
              return true;
          }
      }
  }

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

2621TIntermNode *TParseContext::addConditionInitializer(const TPublicType &pType,
                                                  const ImmutableString &identifier,
                                                  TIntermTyped *initializer,
                                                  const TSourceLoc &loc)
2625{
  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;
2646}

2648TIntermNode *TParseContext::addLoop(TLoopType type,
                                  TIntermNode *init,
                                  TIntermNode *cond,
                                  TIntermTyped *expr,
                                  TIntermNode *body,
                                  const TSourceLoc &line)
2654{
  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 ||(mDiagnostics->numErrors() > 0 || typedCond == nullptr ||
 (typedCond->getBasicType() == EbtBool && !typedCond
->isArray() && !typedCond->isVector()) ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2681, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2681 << "): " << "mDiagnostics->numErrors() > 0 || typedCond == nullptr || (typedCond->getBasicType() == EbtBool && !typedCond->isArray() && !typedCond->isVector())"
))
             (typedCond->getBasicType() == EbtBool && !typedCond->isArray() &&(mDiagnostics->numErrors() > 0 || typedCond == nullptr ||
 (typedCond->getBasicType() == EbtBool && !typedCond
->isArray() && !typedCond->isVector()) ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2681, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2681 << "): " << "mDiagnostics->numErrors() > 0 || typedCond == nullptr || (typedCond->getBasicType() == EbtBool && !typedCond->isArray() && !typedCond->isVector())"
))
              !typedCond->isVector()))(mDiagnostics->numErrors() > 0 || typedCond == nullptr ||
 (typedCond->getBasicType() == EbtBool && !typedCond
->isArray() && !typedCond->isVector()) ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2681, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2681 << "): " << "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)(type != ELoopDoWhile ? static_cast<void>(0) : (!((::gl
::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2688, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2688 << "): " << "type != ELoopDoWhile"
));

  TIntermDeclaration *declaration = cond->getAsDeclarationNode();
  ASSERT(declaration)(declaration ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2691, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2691 << "): " << "declaration"
));
  TIntermBinary *declarator = declaration->getSequence()->front()->getAsBinaryNode();
  ASSERT(declarator->getLeft()->getAsSymbolNode())(declarator->getLeft()->getAsSymbolNode() ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 2693, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 2693 << "): " << "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;
2711}

2713TIntermNode *TParseContext::addIfElse(TIntermTyped *cond,
                                    TIntermNodePair code,
                                    const TSourceLoc &loc)
2716{
  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;
2747}

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

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

2761TPublicType TParseContext::addFullySpecifiedType(const TTypeQualifierBuilder &typeQualifierBuilder,
                                               const TPublicType &typeSpecifier)
2763{
  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;
2837}

2839void TParseContext::checkInputOutputTypeIsValidES3(const TQualifier qualifier,
                                                 const TPublicType &type,
                                                 const TSourceLoc &qualifierLocation)
2842{
  // 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_SHADER0x8B30))
  {
      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));
      }
  }
2915}

2917void TParseContext::checkLocalVariableConstStorageQualifier(const TQualifierWrapperBase &qualifier)
2918{
  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());
      }
  }
2931}

2933void TParseContext::checkMemoryQualifierIsNotSpecified(const TMemoryQualifier &memoryQualifier,
                                                     const TSourceLoc &location)
2935{
  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");
  }
2959}

2961// Make sure there is no offset overlapping, and store the newly assigned offset to "type" in
2962// intermediate tree.
2963void TParseContext::checkAtomicCounterOffsetDoesNotOverlap(bool forceAppend,
                                                         const TSourceLoc &loc,
                                                         TType *type)
2966{
  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);
2987}

2989void TParseContext::checkAtomicCounterOffsetAlignment(const TSourceLoc &location, const TType &type)
2990{
  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");
  }
2998}

3000void TParseContext::checkGeometryShaderInputAndSetArraySize(const TSourceLoc &location,
                                                          const ImmutableString &token,
                                                          TType *type)
3003{
  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)(symbolTable.getGlInVariableWithArraySize() != nullptr ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3012, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3012 << "): " << "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);
      }
  }
3037}

3039void TParseContext::checkTessellationShaderUnsizedArraysAndSetSize(const TSourceLoc &location,
                                                                 const ImmutableString &token,
                                                                 TType *type)
3042{
  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)(mMaxPatchVertices > 0 ? static_cast<void>(0) : (!((
::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL)))
 ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3072, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3072 << "): " << "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()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3093, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3093 << ")"; } while (0);
              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);
      }
  }
3122}

3124TIntermDeclaration *TParseContext::parseSingleDeclaration(
  TPublicType &publicType,
  const TSourceLoc &identifierOrTypeLocation,
  const ImmutableString &identifier)
3128{
  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;
3207}

3209TIntermDeclaration *TParseContext::parseSingleArrayDeclaration(
  TPublicType &elementType,
  const TSourceLoc &identifierLocation,
  const ImmutableString &identifier,
  const TSourceLoc &indexLocation,
  const TVector<unsigned int> &arraySizes)
3215{
  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;
3256}

3258TIntermDeclaration *TParseContext::parseSingleInitDeclaration(const TPublicType &publicType,
                                                            const TSourceLoc &identifierLocation,
                                                            const ImmutableString &identifier,
                                                            const TSourceLoc &initLocation,
                                                            TIntermTyped *initializer)
3263{
  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;
3293}

3295TIntermDeclaration *TParseContext::parseSingleArrayInitDeclaration(
  TPublicType &elementType,
  const TSourceLoc &identifierLocation,
  const ImmutableString &identifier,
  const TSourceLoc &indexLocation,
  const TVector<unsigned int> &arraySizes,
  const TSourceLoc &initLocation,
  TIntermTyped *initializer)
3303{
  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;
3330}

3332TIntermGlobalQualifierDeclaration *TParseContext::parseGlobalQualifierDeclaration(
  const TTypeQualifierBuilder &typeQualifierBuilder,
  const TSourceLoc &identifierLoc,
  const ImmutableString &identifier,
  const TSymbol *symbol)
3337{
  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);
3387}

3389void TParseContext::parseDeclarator(TPublicType &publicType,
                                  const TSourceLoc &identifierLocation,
                                  const ImmutableString &identifier,
                                  TIntermDeclaration *declarationOut)
3393{
  // 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);
  }
3427}

3429void TParseContext::parseArrayDeclarator(TPublicType &elementType,
                                       const TSourceLoc &identifierLocation,
                                       const ImmutableString &identifier,
                                       const TSourceLoc &arrayLocation,
                                       const TVector<unsigned int> &arraySizes,
                                       TIntermDeclaration *declarationOut)
3435{
  // 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);
      }
  }
3473}

3475void TParseContext::parseInitDeclarator(const TPublicType &publicType,
                                      const TSourceLoc &identifierLocation,
                                      const ImmutableString &identifier,
                                      const TSourceLoc &initLocation,
                                      TIntermTyped *initializer,
                                      TIntermDeclaration *declarationOut)
3481{
  // 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);
      }
  }
3504}

3506void 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)
3514{
  // 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);
      }
  }
3539}

3541TIntermNode *TParseContext::addEmptyStatement(const TSourceLoc &location)
3542{
  // 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;
3548}

3550void TParseContext::setAtomicCounterBindingDefaultOffset(const TPublicType &publicType,
                                                       const TSourceLoc &location)
3552{
  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);
3561}

3563void TParseContext::parseDefaultPrecisionQualifier(const TPrecision precision,
                                                 const TPublicType &type,
                                                 const TSourceLoc &loc)
3566{
  if ((precision == EbpHigh) && (getShaderType() == GL_FRAGMENT_SHADER0x8B30) &&
      !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);
3580}

3582bool TParseContext::checkPrimitiveTypeMatchesTypeQualifier(const TTypeQualifier &typeQualifier)
3583{
  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()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3600, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3600 << ")"; } while (0);
          return false;
  }
3603}

3605void TParseContext::setGeometryShaderInputArraySize(unsigned int inputArraySize,
                                                  const TSourceLoc &line)
3607{
  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;
3616}

3618bool TParseContext::parseGeometryShaderInputLayoutQualifier(const TTypeQualifier &typeQualifier)
3619{
  ASSERT(typeQualifier.qualifier == EvqGeometryIn)(typeQualifier.qualifier == EvqGeometryIn ? static_cast<void
>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl
::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3620, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3620 << "): " << "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;
3679}

3681bool TParseContext::parseGeometryShaderOutputLayoutQualifier(const TTypeQualifier &typeQualifier)
3682{
  ASSERT(typeQualifier.qualifier == EvqGeometryOut)(typeQualifier.qualifier == EvqGeometryOut ? static_cast<void
>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl
::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3683, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3683 << "): " << "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;
3731}

3733bool TParseContext::parseTessControlShaderOutputLayoutQualifier(const TTypeQualifier &typeQualifier)
3734{
  ASSERT(typeQualifier.qualifier == EvqTessControlOut)(typeQualifier.qualifier == EvqTessControlOut ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3735, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3735 << "): " << "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;
3762}

3764bool TParseContext::parseTessEvaluationShaderInputLayoutQualifier(
  const TTypeQualifier &typeQualifier)
3766{
  ASSERT(typeQualifier.qualifier == EvqTessEvaluationIn)(typeQualifier.qualifier == EvqTessEvaluationIn ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 3767, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 3767 << "): " << "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;
3821}

3823void TParseContext::parseGlobalLayoutQualifier(const TTypeQualifierBuilder &typeQualifierBuilder)
3824{
  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;
          }
      }
  }
4090}

4092TIntermFunctionPrototype *TParseContext::createPrototypeNodeFromFunction(
  const TFunction &function,
  const TSourceLoc &location,
  bool insertParametersToSymbolTable)
4096{
  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())(!param->getType().isUnsizedArray() ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4118, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4118 << "): " << "!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;
4131}

4133TIntermFunctionPrototype *TParseContext::addFunctionPrototypeDeclaration(
  const TFunction &parsedFunction,
  const TSourceLoc &location)
4136{
  // 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;
4163}

4165TIntermFunctionDefinition *TParseContext::addFunctionDefinition(
  TIntermFunctionPrototype *functionPrototype,
  TIntermBlock *functionBody,
  const TSourceLoc &location)
4169{
  // 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;
4195}

4197void TParseContext::parseFunctionDefinitionHeader(const TSourceLoc &location,
                                                const TFunction *function,
                                                TIntermFunctionPrototype **prototypeOut)
4200{
  ASSERT(function)(function ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4201, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4201 << "): " << "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();
  }
4223}

4225TFunction *TParseContext::parseFunctionDeclarator(const TSourceLoc &location, TFunction *function)
4226{
  //
  // 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;
4332}

4334TFunction *TParseContext::parseFunctionHeader(const TPublicType &type,
                                            const ImmutableString &name,
                                            const TSourceLoc &location)
4337{
  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)(!type.isArray() || mDiagnostics->numErrors() > 0 ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4355, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4355 << "): " << "!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);
4369}

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

4377TFunctionLookup *TParseContext::addConstructorFunc(const TPublicType &publicType)
4378{
  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);
4398}

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

4412TParameter TParseContext::parseParameterDeclarator(TType *type,
                                                 const ImmutableString &name,
                                                 const TSourceLoc &nameLoc)
4415{
  ASSERT(type)(type ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4416, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4416 << "): " << "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;
4425}

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

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

4447bool TParseContext::checkUnsizedArrayConstructorArgumentDimensionality(
  const TIntermSequence &arguments,
  TType type,
  const TSourceLoc &line)
4451{
  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)(element ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4460, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4460 << "): " << "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;
4485}

4487// This function is used to test for the correctness of the parameters passed to various constructor
4488// functions and also convert them to the right datatype if it is allowed and required.
4489//
4490// Returns a node to add to the tree regardless of if an error was generated or not.
4491//
4492TIntermTyped *TParseContext::addConstructor(TFunctionLookup *fnCall, const TSourceLoc &line)
4493{
  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)(firstElement ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4504, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4504 << "): " << "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())(!type.isUnsizedArray() ? static_cast<void>(0) : (!((::
gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ?
 static_cast<void>(0) : ::gl::priv::LogMessageVoidify()
 & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4516, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4516 << "): " << "!type.isUnsizedArray()"
));
  }

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

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

  return constructorNode->fold(mDiagnostics);
4528}

4530//
4531// Interface/uniform blocks
4532TIntermDeclaration *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)
4541{
  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_SHADER0x8E88)
      {
          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_SHADER0x8E87)
      {
          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_SHADER0x8E88;
          const bool isTESIn =
              mShaderType == GL_TESS_EVALUATION_SHADER0x8E87 && 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_EXT0x8DD9 && IsVaryingIn(typeQualifier.qualifier))
          {
              ASSERT(arrayDimensions > 0)(arrayDimensions > 0 ? static_cast<void>(0) : (!((::
gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ?
 static_cast<void>(0) : ::gl::priv::LogMessageVoidify()
 & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 4645, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 4645 << "): " << "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_EXT0x8DD9 &&
           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;
4937}

4939void TParseContext::enterStructDeclaration(const TSourceLoc &line,
                                         const ImmutableString &identifier)
4941{
  ++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");
  }
4950}

4952void TParseContext::exitStructDeclaration()
4953{
  --mStructNestingLevel;
4955}

4957void TParseContext::checkIsBelowStructNestingLimit(const TSourceLoc &line, const TField &field)
4958{
  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;
  }
4989}

4991//
4992// Parse an array index expression
4993//
4994TIntermTyped *TParseContext::addIndexExpression(TIntermTyped *baseExpression,
                                              const TSourceLoc &location,
                                              TIntermTyped *indexExpression)
4997{
  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_EXT0x8DD9)
      {
          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)(mDiagnostics->numErrors() > 0 ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5064, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5064 << "): " << "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())(baseExpression->isVector() ? static_cast<void>(0) :
 (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5164, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5164 << "): " << "baseExpression->isVector()"
));
                  safeIndex = checkIndexLessThan(outOfRangeIndexIsError, location, index,
                                                 baseExpression->getType().getNominalSize(),
                                                 "vector field selection out of range");
              }
          }

          ASSERT(safeIndex >= 0)(safeIndex >= 0 ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5171, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5171 << "): " << "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;
5195}

5197int TParseContext::checkIndexLessThan(bool outOfRangeIndexIsError,
                                    const TSourceLoc &location,
                                    int index,
                                    int arraySize,
                                    const char *reason)
5202{
  // Should not reach here with an unsized / runtime-sized array.
  ASSERT(arraySize > 0)(arraySize > 0 ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5204, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5204 << "): " << "arraySize > 0"
));
  // A negative index should already have been checked.
  ASSERT(index >= 0)(index >= 0 ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5206, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5206 << "): " << "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;
5216}

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

  if (baseExpression->isVector())
2
←
Taking true branch→
  {
      TVector<int> fieldOffsets;
      if (!parseVectorFields(fieldLocation, fieldString, baseExpression->getNominalSize(),
3
←
Calling 'TParseContext::parseVectorFields'→
                             &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;
  }
5332}

5334TLayoutQualifier TParseContext::parseLayoutQualifier(const ImmutableString &qualifierType,
                                                   const TSourceLoc &qualifierTypeLine)
5336{
  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_SHADER0x8B30)
  {
      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_EXT0x8DD9 &&
           (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_EXT0x8E87 &&
           (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_SHADER0x8B30)
  {
      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;
5653}

5655void TParseContext::parseLocalSize(const ImmutableString &qualifierType,
                                 const TSourceLoc &qualifierTypeLine,
                                 int intValue,
                                 const TSourceLoc &intValueLine,
                                 const std::string &intValueString,
                                 size_t index,
                                 sh::WorkGroupSize *localSize)
5662{
  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;
5672}

5674void TParseContext::parseNumViews(int intValue,
                                const TSourceLoc &intValueLine,
                                const std::string &intValueString,
                                int *numViews)
5678{
  // 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;
5686}

5688void TParseContext::parseInvocations(int intValue,
                                   const TSourceLoc &intValueLine,
                                   const std::string &intValueString,
                                   int *numInvocations)
5692{
  // 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;
  }
5706}

5708void TParseContext::parseMaxVertices(int intValue,
                                   const TSourceLoc &intValueLine,
                                   const std::string &intValueString,
                                   int *maxVertices)
5712{
  // 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;
  }
5726}

5728void TParseContext::parseVertices(int intValue,
                                const TSourceLoc &intValueLine,
                                const std::string &intValueString,
                                int *vertices)
5732{
  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;
  }
5743}

5745void TParseContext::parseIndexLayoutQualifier(int intValue,
                                            const TSourceLoc &intValueLine,
                                            const std::string &intValueString,
                                            int *index)
5749{
  // 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;
  }
5763}

5765TLayoutQualifier TParseContext::parseLayoutQualifier(const ImmutableString &qualifierType,
                                                   const TSourceLoc &qualifierTypeLine,
                                                   int intValue,
                                                   const TSourceLoc &intValueLine)
5769{
  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_SHADER0x8B31)
  {
      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_EXT0x8DD9 &&
           (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_EXT0x8DD9 &&
           (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_SHADER0x8B30 &&
           checkCanUseExtension(qualifierTypeLine, TExtension::EXT_blend_func_extended))
  {
      parseIndexLayoutQualifier(intValue, intValueLine, intValueString, &qualifier.index);
  }
  else if (qualifierType == "vertices" && mShaderType == GL_TESS_CONTROL_SHADER_EXT0x8E88 &&
           (mShaderVersion >= 320 ||
            checkCanUseExtension(qualifierTypeLine, TExtension::EXT_tessellation_shader)))
  {
      parseVertices(intValue, intValueLine, intValueString, &qualifier.vertices);
  }
  else
  {
      error(qualifierTypeLine, "invalid layout qualifier", qualifierType);
  }

  return qualifier;
5876}

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

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

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

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

  switch (getShaderType())
  {
      case GL_VERTEX_SHADER0x8B31:
      {
          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_SHADER0x8B30:
      {
          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_SHADER0x91B9:
      {
          return new TStorageQualifierWrapper(EvqComputeIn, loc);
      }
      case GL_GEOMETRY_SHADER0x8DD9:
      {
          return new TStorageQualifierWrapper(EvqGeometryIn, loc);
      }
      case GL_TESS_CONTROL_SHADER0x8E88:
      {
          return new TStorageQualifierWrapper(EvqTessControlIn, loc);
      }
      case GL_TESS_EVALUATION_SHADER0x8E87:
      {
          return new TStorageQualifierWrapper(EvqTessEvaluationIn, loc);
      }
      default:
      {
          UNREACHABLE()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5945, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5945 << ")"; } while (0);
          return new TStorageQualifierWrapper(EvqLast, loc);
      }
  }
5949}

5951TStorageQualifierWrapper *TParseContext::parseOutQualifier(const TSourceLoc &loc)
5952{
  if (declaringFunction())
  {
      return new TStorageQualifierWrapper(EvqParamOut, loc);
  }
  switch (getShaderType())
  {
      case GL_VERTEX_SHADER0x8B31:
      {
          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_SHADER0x8B30:
      {
          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_SHADER0x91B9:
      {
          error(loc, "storage qualifier isn't supported in compute shaders", "out");
          return new TStorageQualifierWrapper(EvqParamOut, loc);
      }
      case GL_GEOMETRY_SHADER_EXT0x8DD9:
      {
          return new TStorageQualifierWrapper(EvqGeometryOut, loc);
      }
      case GL_TESS_CONTROL_SHADER_EXT0x8E88:
      {
          return new TStorageQualifierWrapper(EvqTessControlOut, loc);
      }
      case GL_TESS_EVALUATION_SHADER_EXT0x8E87:
      {
          return new TStorageQualifierWrapper(EvqTessEvaluationOut, loc);
      }
      default:
      {
          UNREACHABLE()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 5994, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 5994 << ")"; } while (0);
          return new TStorageQualifierWrapper(EvqLast, loc);
      }
  }
5998}

6000TStorageQualifierWrapper *TParseContext::parseInOutQualifier(const TSourceLoc &loc)
6001{
  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_SHADER0x8B30)
      {
          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);
6026}

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

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

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

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

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

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

6087TFieldList *TParseContext::addStructDeclaratorListWithQualifiers(
  const TTypeQualifierBuilder &typeQualifierBuilder,
  TPublicType *typeSpecifier,
  const TDeclaratorList *declaratorList)
6091{
  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);
6104}

6106TFieldList *TParseContext::addStructDeclaratorList(const TPublicType &typeSpecifier,
                                                 const TDeclaratorList *declaratorList)
6108{
  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;
6149}

6151TTypeSpecifierNonArray TParseContext::addStructure(const TSourceLoc &structLine,
                                                 const TSourceLoc &nameLine,
                                                 const ImmutableString &structName,
                                                 TFieldList *fieldList)
6155{
  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;
6221}

6223TIntermSwitch *TParseContext::addSwitch(TIntermTyped *init,
                                      TIntermBlock *statementList,
                                      const TSourceLoc &loc)
6226{
  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)(statementList ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6236, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6236 << "): " << "statementList"
));
  if (!ValidateSwitchStatementList(switchType, mDiagnostics, statementList, loc))
  {
      ASSERT(mDiagnostics->numErrors() > 0)(mDiagnostics->numErrors() > 0 ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6239, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6239 << "): " << "mDiagnostics->numErrors() > 0"
));
      return nullptr;
  }

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

6249TIntermCase *TParseContext::addCase(TIntermTyped *condition, const TSourceLoc &loc)
6250{
  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;
6278}

6280TIntermCase *TParseContext::addDefault(const TSourceLoc &loc)
6281{
  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;
6290}

6292TIntermTyped *TParseContext::createUnaryMath(TOperator op,
                                           TIntermTyped *child,
                                           const TSourceLoc &loc,
                                           const TFunction *func)
6296{
  ASSERT(child != nullptr)(child != nullptr ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6297, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6297 << "): " << "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);
6349}

6351TIntermTyped *TParseContext::addUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc)
6352{
  ASSERT(op != EOpNull)(op != EOpNull ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6353, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6353 << "): " << "op != EOpNull"
));
  TIntermTyped *node = createUnaryMath(op, child, loc, nullptr);
  if (node == nullptr)
  {
      return child;
  }
  return node;
6360}

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

6370TIntermTyped *TParseContext::expressionOrFoldedResult(TIntermTyped *expression)
6371{
  // 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)(folded != nullptr ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6380, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6380 << "): " << "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;
6392}

6394bool TParseContext::binaryOpCommonCheck(TOperator op,
                                      TIntermTyped *left,
                                      TIntermTyped *right,
                                      const TSourceLoc &loc)
6398{
  // 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)(op != EOpIndexDirectStruct ? static_cast<void>(0) : (!
((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL)
)) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6410, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6410 << "): " << "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())(left->getType().getStruct() ? static_cast<void>(0) :
 (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6445, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6445 << "): " << "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())(left->getType().getInterfaceBlock() ? static_cast<void
>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl
::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6467, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6467 << "): " << "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())(right->isArray() ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6483, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6483 << "): " << "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;
6642}

6644bool TParseContext::isMultiplicationTypeCombinationValid(TOperator op,
                                                       const TType &left,
                                                       const TType &right)
6647{
  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())(!left.isMatrix() && !right.isMatrix() ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6657, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6657 << "): " << "!left.isMatrix() && !right.isMatrix()"
));
          return left.isVector() && !right.isVector();
      case EOpVectorTimesMatrix:
          return left.getNominalSize() == right.getRows();
      case EOpVectorTimesMatrixAssign:
          ASSERT(!left.isMatrix() && right.isMatrix())(!left.isMatrix() && right.isMatrix() ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6662, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6662 << "): " << "!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())(left.isMatrix() && !right.isMatrix() ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6670, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6670 << "): " << "left.isMatrix() && !right.isMatrix()"
));
          return !right.isVector();
      case EOpMatrixTimesMatrix:
          return left.getCols() == right.getRows();
      case EOpMatrixTimesMatrixAssign:
          ASSERT(left.isMatrix() && right.isMatrix())(left.isMatrix() && right.isMatrix() ? static_cast<
void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(
::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv::
LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6675, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6675 << "): " << "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()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6682, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6682 << ")"; } while (0);
          return false;
  }
6685}

6687TIntermTyped *TParseContext::addBinaryMathInternal(TOperator op,
                                                 TIntermTyped *left,
                                                 TIntermTyped *right,
                                                 const TSourceLoc &loc)
6691{
  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() &&(!left->isArray() && !right->isArray() &&
 !left->getType().getStruct() && !right->getType
().getStruct() ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6708, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6708 << "): " << "!left->isArray() && !right->isArray() && !left->getType().getStruct() && !right->getType().getStruct()"
))
                 !right->getType().getStruct())(!left->isArray() && !right->isArray() &&
 !left->getType().getStruct() && !right->getType
().getStruct() ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6708, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6708 << "): " << "!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)(right->getBasicType() == EbtBool ? static_cast<void>
(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6714, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6714 << "): " << "right->getBasicType() == EbtBool"
));
          break;
      case EOpAdd:
      case EOpSub:
      case EOpDiv:
      case EOpMul:
          ASSERT(!left->isArray() && !right->isArray() && !left->getType().getStruct() &&(!left->isArray() && !right->isArray() &&
 !left->getType().getStruct() && !right->getType
().getStruct() ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6721, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6721 << "): " << "!left->isArray() && !right->isArray() && !left->getType().getStruct() && !right->getType().getStruct()"
))
                 !right->getType().getStruct())(!left->isArray() && !right->isArray() &&
 !left->getType().getStruct() && !right->getType
().getStruct() ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6721, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6721 << "): " << "!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() &&(!left->isArray() && !right->isArray() &&
 !left->getType().getStruct() && !right->getType
().getStruct() ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6729, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6729 << "): " << "!left->isArray() && !right->isArray() && !left->getType().getStruct() && !right->getType().getStruct()"
))
                 !right->getType().getStruct())(!left->isArray() && !right->isArray() &&
 !left->getType().getStruct() && !right->getType
().getStruct() ? static_cast<void>(0) : (!((::gl::priv::
ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6729, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6729 << "): " << "!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)(op != EOpAssign ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6750, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6750 << "): " << "op != EOpAssign"
));
  markStaticReadIfSymbol(left);
  markStaticReadIfSymbol(right);
  node->setLine(loc);
  return expressionOrFoldedResult(node);
6755}

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

6771TIntermTyped *TParseContext::addBinaryMathBooleanResult(TOperator op,
                                                      TIntermTyped *left,
                                                      TIntermTyped *right,
                                                      const TSourceLoc &loc)
6775{
  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;
6784}

6786TIntermTyped *TParseContext::addAssign(TOperator op,
                                     TIntermTyped *left,
                                     TIntermTyped *right,
                                     const TSourceLoc &loc)
6790{
  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;
6828}

6830TIntermTyped *TParseContext::addComma(TIntermTyped *left,
                                    TIntermTyped *right,
                                    const TSourceLoc &loc)
6833{
  // 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);
6852}

6854TIntermBranch *TParseContext::addBranch(TOperator op, const TSourceLoc &loc)
6855{
  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_SHADER0x8B30)
          {
              error(loc, "discard supported in fragment shaders only", "discard");
          }
          else
          {
              errorIfPLSDeclared(loc, PLSIllegalOperations::Discard);
          }
          mHasDiscard = true;
          break;
      default:
          UNREACHABLE()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6892, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6892 << ")"; } while (0);
          break;
  }
  return addBranch(op, nullptr, loc);
6896}

6898TIntermBranch *TParseContext::addBranch(TOperator op,
                                      TIntermTyped *expression,
                                      const TSourceLoc &loc)
6901{
  if (expression != nullptr)
  {
      markStaticReadIfSymbol(expression);
      ASSERT(op == EOpReturn)(op == EOpReturn ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6905, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6905 << "): " << "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;
6919}

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

6930void TParseContext::checkTextureGather(TIntermAggregate *functionCall)
6931{
  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)(arguments->size() >= 2u && arguments->size(
) <= 4u ? static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6940, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6940 << "): " << "arguments->size() >= 2u && arguments->size() <= 4u"
));
      const TIntermTyped *sampler = arguments->front()->getAsTyped();
      ASSERT(sampler != nullptr)(sampler != nullptr ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6942, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6942 << "): " << "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)(!isTextureGatherOffsetOrOffsets ? static_cast<void>(0)
 : (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6963, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6963 << "): " << "!isTextureGatherOffsetOrOffsets"
));
              if (arguments->size() == 3u)
              {
                  componentNode = arguments->back();
              }
              break;
          case EbtSampler2DShadow:
          case EbtSampler2DArrayShadow:
          case EbtSamplerCubeShadow:
          case EbtSamplerCubeArrayShadow:
              break;
          default:
              UNREACHABLE()do { !((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 6975, ::gl::LOG_FATAL).stream()) << "\t! Unreachable reached: "
 << __FUNCTION__ << "(" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 6975 << ")"; } while (0);
              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());
              }
          }
      }
  }
6998}

7000void TParseContext::checkTextureOffset(TIntermAggregate *functionCall)
7001{
  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)(arguments->size() >= 3 ? static_cast<void>(0) : (
!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7016, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7016 << "): " << "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)(!offsetMustBeConst ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7095, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7095 << "): " << "!offsetMustBeConst"
));
          return;
      }

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

7105void TParseContext::checkSingleTextureOffset(const TSourceLoc &line,
                                           const TConstantUnion *values,
                                           size_t size,
                                           int minOffsetValue,
                                           int maxOffsetValue)
7110{
  for (size_t i = 0u; i < size; ++i)
  {
      ASSERT(values[i].getType() == EbtInt)(values[i].getType() == EbtInt ? static_cast<void>(0) :
 (!((::gl::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL
))) ? static_cast<void>(0) : ::gl::priv::LogMessageVoidify
() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7113, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7113 << "): " << "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());
      }
  }
7123}

7125void TParseContext::checkInterpolationFS(TIntermAggregate *functionCall)
7126{
  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())(static_cast <bool> (functionCall->getAsUnaryNode())
 ? void (0) : __assert_fail ("functionCall->getAsUnaryNode()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      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());
  }
7158}

7160void TParseContext::checkAtomicMemoryBuiltinFunctions(TIntermAggregate *functionCall)
7161{
  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());
  }
7191}

7193// GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
7194void TParseContext::checkImageMemoryAccessForBuiltinFunctions(TIntermAggregate *functionCall)
7195{
  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));
          }
      }
  }
7239}

7241// GLSL ES 3.10 Revision 4, 13.51 Matching of Memory Qualifiers in Function Parameters
7242void TParseContext::checkImageMemoryAccessForUserDefinedFunctions(
  const TFunction *functionDefinition,
  const TIntermAggregate *functionCall)
7245{
  ASSERT(functionCall->getOp() == EOpCallFunctionInAST)(functionCall->getOp() == EOpCallFunctionInAST ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7246, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7246 << "): " << "functionCall->getOp() == EOpCallFunctionInAST"
));

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

  ASSERT(functionDefinition->getParamCount() == arguments.size())(functionDefinition->getParamCount() == arguments.size() ?
 static_cast<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7250, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7250 << "): " << "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())(functionArgumentType.getBasicType() == functionParameterType
.getBasicType() ? static_cast<void>(0) : (!((::gl::priv
::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7257, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7257 << "): " << "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));
          }
      }
  }
7298}

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

7313TIntermTyped *TParseContext::addMethod(TFunctionLookup *fnCall, const TSourceLoc &loc)
7314{
  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)(mShaderType == 0x8DD9 ? static_cast<void>(0) : (!((::gl
::priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7335, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7335 << "): " << "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));
7346}

7348TIntermTyped *TParseContext::addNonConstructorFunctionCall(TFunctionLookup *fnCall,
                                                         const TSourceLoc &loc)
7350{
  // 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)(symbol->symbolType() == SymbolType::UserDefined ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7374, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7374 << "): " << "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)(symbol->symbolType() == SymbolType::BuiltIn ? static_cast
<void>(0) : (!((::gl::priv::ShouldCreatePlatformLogMessage
(::gl::LOG_FATAL))) ? static_cast<void>(0) : ::gl::priv
::LogMessageVoidify() & (::gl::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7396, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7396 << "): " << "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)(callNode != nullptr ? static_cast<void>(0) : (!((::gl::
priv::ShouldCreatePlatformLogMessage(::gl::LOG_FATAL))) ? static_cast
<void>(0) : ::gl::priv::LogMessageVoidify() & (::gl
::LogMessage("/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
, __FUNCTION__, 7413, ::gl::LOG_FATAL).stream()) << "\t! Assert failed in "
 << __FUNCTION__ << " (" << "/root/firefox-clang/gfx/angle/checkout/src/compiler/translator/ParseContext.cpp"
 << ":" << 7413 << "): " << "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));
7442}

7444TIntermTyped *TParseContext::addTernarySelection(TIntermTyped *cond,
                                               TIntermTyped *trueExpression,
                                               TIntermTyped *falseExpression,
                                               const TSourceLoc &loc)
7448{
  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);
7511}

7513//
7514// Parse an array of strings using yyparse.
7515//
7516// Returns 0 for success.
7517//
7518int PaParseStrings(size_t count,
                 const char *const string[],
                 const int length[],
                 TParseContext *context)
7522{
  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;
7536}

7538}  // namespace sh