Disallow interface blocks in arithmetic expressions

src/compiler/translator/ParseContext.cpp

@@ -3688,8 +3688,9 @@ TIntermTyped *TParseContext::createUnaryMath(TOperator op,
         case EOpPreDecrement:
         case EOpNegative:
         case EOpPositive:
-            if (child->getBasicType() == EbtStruct || child->getBasicType() == EbtBool ||
-                child->isArray() || IsOpaqueType(child->getBasicType()))
+            if (child->getBasicType() == EbtStruct || child->isInterfaceBlock() ||
+                child->getBasicType() == EbtBool || child->isArray() ||
+                IsOpaqueType(child->getBasicType()))
             {
                 unaryOpError(loc, GetOperatorString(op), child->getCompleteString());
                 return nullptr;
@@ -3773,6 +3774,19 @@ bool TParseContext::binaryOpCommonCheck(TOperator op,
         }
     }
 
+    if (left->isInterfaceBlock() || right->isInterfaceBlock())
+    {
+        switch (op)
+        {
+            case EOpIndexDirectInterfaceBlock:
+                ASSERT(left->getType().getInterfaceBlock());
+                break;
+            default:
+                error(loc, "Invalid operation for interface blocks", GetOperatorString(op));
+                return false;
+        }
+    }
+
     if (left->isArray() || right->isArray())
     {
         if (mShaderVersion < 300)
@@ -4532,6 +4546,12 @@ TIntermTyped *TParseContext::addTernarySelection(TIntermTyped *cond,
         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)

src/tests/compiler_tests/ShaderValidation_test.cpp

@@ -3797,3 +3797,64 @@ TEST_F(FragmentShaderValidationTest, InvalidExpressionForSamplerOperands)
         FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
     }
 }
+
+// Test interface blocks as invalid operands to a binary expression.
+TEST_F(FragmentShaderValidationTest, InvalidInterfaceBlockBinaryExpression)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "uniform U\n"
+        "{\n"
+        "    int foo; \n"
+        "} u;\n"
+        "void main()\n"
+        "{\n"
+        "    u + u;\n"
+        "}\n";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Test interface block as an invalid operand to an unary expression.
+TEST_F(FragmentShaderValidationTest, InvalidInterfaceBlockUnaryExpression)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "uniform U\n"
+        "{\n"
+        "    int foo; \n"
+        "} u;\n"
+        "void main()\n"
+        "{\n"
+        "    +u;\n"
+        "}\n";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}
+
+// Test interface block as an invalid operand to a ternary expression.
+// Note that the spec is not very explicit on this, but it makes sense to forbid this.
+TEST_F(FragmentShaderValidationTest, InvalidInterfaceBlockTernaryExpression)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "uniform U\n"
+        "{\n"
+        "    int foo; \n"
+        "} u;\n"
+        "void main()\n"
+        "{\n"
+        "    true ? u : u;\n"
+        "}\n";
+
+    if (compile(shaderString))
+    {
+        FAIL() << "Shader compilation succeeded, expecting failure:\n" << mInfoLog;
+    }
+}