Add support for parsing ESSL3 invariant qualifiers

include/GLSLANG/ShaderLang.h

@@ -48,7 +48,7 @@ typedef unsigned int GLenum;
 
 // Version number for shader translation API.
 // It is incremented every time the API changes.
-#define ANGLE_SH_VERSION 135
+#define ANGLE_SH_VERSION 136
 
 typedef enum {
   SH_GLES2_SPEC = 0x8B40,

include/GLSLANG/ShaderVars.h

@@ -161,8 +161,10 @@ struct COMPILER_EXPORT Varying : public ShaderVariable
 
     // Decide whether two varyings are the same at shader link time,
     // assuming one from vertex shader and the other from fragment shader.
-    // See GLSL ES Spec 3.00.3, sec 4.3.9.
-    bool isSameVaryingAtLinkTime(const Varying &other) const;
+    // Invariance needs to match only in ESSL1. Relevant spec sections:
+    // GLSL ES 3.00.4, sections 4.6.1 and 4.3.9.
+    // GLSL ES 1.00.17, section 4.6.4.
+    bool isSameVaryingAtLinkTime(const Varying &other, int shaderVersion) const;
 
     InterpolationType interpolation;
     bool isInvariant;

src/compiler/translator/ParseContext.cpp

@@ -12,6 +12,7 @@
 #include "compiler/preprocessor/SourceLocation.h"
 #include "compiler/translator/glslang.h"
 #include "compiler/translator/ValidateSwitch.h"
+#include "compiler/translator/util.h"
 
 ///////////////////////////////////////////////////////////////////////
 //
@@ -969,6 +970,15 @@ bool TParseContext::functionCallLValueErrorCheck(const TFunction *fnCandidate, T
     return false;
 }
 
+void TParseContext::es3InvariantErrorCheck(const TQualifier qualifier, const TSourceLoc &invariantLocation)
+{
+    if (!sh::IsVaryingOut(qualifier) && qualifier != EvqFragmentOut)
+    {
+        error(invariantLocation, "Only out variables can be invariant.", "invariant");
+        recover();
+    }
+}
+
 bool TParseContext::supportsExtension(const char* extension)
 {
     const TExtensionBehavior& extbehavior = extensionBehavior();

src/compiler/translator/ParseContext.h

@@ -110,6 +110,7 @@ struct TParseContext {
     bool singleDeclarationErrorCheck(TPublicType &publicType, const TSourceLoc &identifierLocation);
     bool layoutLocationErrorCheck(const TSourceLoc& location, const TLayoutQualifier &layoutQualifier);
     bool functionCallLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *);
+    void es3InvariantErrorCheck(const TQualifier qualifier, const TSourceLoc &invariantLocation);
 
     const TPragma& pragma() const { return directiveHandler.pragma(); }
     const TExtensionBehavior& extensionBehavior() const { return directiveHandler.extensionBehavior(); }

src/compiler/translator/ShaderVars.cpp

@@ -303,11 +303,11 @@ bool Varying::operator==(const Varying &other) const
             isInvariant == other.isInvariant);
 }
 
-bool Varying::isSameVaryingAtLinkTime(const Varying &other) const
+bool Varying::isSameVaryingAtLinkTime(const Varying &other, int shaderVersion) const
 {
     return (ShaderVariable::isSameVariableAtLinkTime(other, false) &&
             interpolation == other.interpolation &&
-            isInvariant == other.isInvariant);
+            (shaderVersion >= 300 || isInvariant == other.isInvariant));
 }
 
 InterfaceBlock::InterfaceBlock()

src/compiler/translator/glslang.y

@@ -1012,6 +1012,16 @@ type_qualifier
         $$.setBasic(EbtVoid, $2.qualifier, @2);
         $$.layoutQualifier = $1;
     }
+    | INVARIANT storage_qualifier {
+        context->es3InvariantErrorCheck($2.qualifier, @1);
+        $$.setBasic(EbtVoid, $2.qualifier, @2);
+        $$.invariant = true;
+    }
+    | INVARIANT interpolation_qualifier storage_qualifier {
+        context->es3InvariantErrorCheck($3.qualifier, @1);
+        $$ = context->joinInterpolationQualifiers(@2, $2.qualifier, @3, $3.qualifier);
+        $$.invariant = true;
+    }
     ;
 
 storage_qualifier

src/compiler/translator/util.cpp

@@ -299,6 +299,10 @@ void GetVariableTraverser::setTypeSpecificInfo(
     {
       case EvqVaryingIn:
       case EvqVaryingOut:
+      case EvqVertexOut:
+      case EvqSmoothOut:
+      case EvqFlatOut:
+      case EvqCentroidOut:
         if (mSymbolTable.isVaryingInvariant(std::string(name.c_str())) || type.isInvariant())
         {
             variable->isInvariant = true;

src/tests/compiler_tests/ShaderVariable_test.cpp

@@ -211,11 +211,15 @@ TEST(ShaderVariableTest, IsSameVaryingWithDifferentInvariance)
     fx.staticUse = true;
     fx.isInvariant = false;
 
-    EXPECT_FALSE(vx.isSameVaryingAtLinkTime(fx));
+    // Default to ESSL1 behavior: invariance must match
+    EXPECT_FALSE(vx.isSameVaryingAtLinkTime(fx, 100));
+    // ESSL3 behavior: invariance doesn't need to match
+    EXPECT_TRUE(vx.isSameVaryingAtLinkTime(fx, 300));
 
     // invariant varying float vary;
     fx.isInvariant = true;
-    EXPECT_TRUE(vx.isSameVaryingAtLinkTime(fx));
+    EXPECT_TRUE(vx.isSameVaryingAtLinkTime(fx, 100));
+    EXPECT_TRUE(vx.isSameVaryingAtLinkTime(fx, 300));
 }
 
 // Test that using invariant varyings doesn't trigger a double delete.