Update of the typer with shifts and assignments (#1154)

Updates the Typer class to produce a result in the case of assignments
and the TyperHelper class to correctly type shift operations in the
case of left and right scalar types (the resulting type is the one
from the left operand).

Adds a test for the typer with left and right shift operators.
Ensures that the typer produce the correct type for shift operations
on vectors and rewrite comments accordingly.

Author: AaronGhost

ast/src/main/java/com/graphicsfuzz/common/typing/Typer.java

@@ -402,17 +402,13 @@ public void visitBinaryExpr(BinaryExpr binaryExpr) {
         types.put(binaryExpr, rhsType);
         return;
       case BAND_ASSIGN:
-        break;
       case BOR_ASSIGN:
-        break;
       case BXOR_ASSIGN:
-        break;
       case MOD_ASSIGN:
-        break;
       case SHL_ASSIGN:
-        break;
       case SHR_ASSIGN:
-        break;
+        types.put(binaryExpr, lhsType);
+        return;
       default:
         break;
 

ast/src/main/java/com/graphicsfuzz/common/typing/TyperHelper.java

@@ -58,18 +58,23 @@ public static Type resolveTypeOfCommonBinary(Type lhsType, Type rhsType) {
       return lhsType;
     }
 
-    // If one side is scalar and the other side is basic, the result has to be that of the other
-    // side
-    if (lhsType == BasicType.FLOAT || lhsType == BasicType.INT || lhsType == BasicType.UINT) {
-      assert rhsType instanceof BasicType;
-      return rhsType;
-    }
+    // If one side is scalar, the other side is either a scalar of different type or a non-scalar
+    // basic type:
+    // - If the two operands are scalar of different types, the operation is a shift and
+    // the result type is the type of the left operand
+    // - If one operand is scalar and the other is basic, the result type is the one of the basic
+    // type
     if (rhsType == BasicType.FLOAT || rhsType == BasicType.INT || rhsType == BasicType.UINT) {
       assert lhsType instanceof BasicType;
       return lhsType;
     }
+    if (lhsType == BasicType.FLOAT || lhsType == BasicType.INT || lhsType == BasicType.UINT) {
+      assert rhsType instanceof BasicType;
+      return rhsType;
+    }
     // Now we are in a position where if we know that one type is vector
-    // or matrix, the other side must be also
+    // or matrix, the other side must be also and the result type is the one from the type on the
+    // left if the two types are different (shift operations)
     for (BasicType t : Arrays.asList(
         BasicType.VEC2,
         BasicType.VEC3,
@@ -89,7 +94,7 @@ public static Type resolveTypeOfCommonBinary(Type lhsType, Type rhsType) {
         BasicType.MAT4X2,
         BasicType.MAT4X3,
         BasicType.MAT4X4)) {
-      if (lhsType == t || rhsType == t) {
+      if (lhsType == t) {
         return t;
       }
     }

ast/src/test/java/com/graphicsfuzz/common/typing/TyperTest.java

@@ -884,6 +884,122 @@ public void visitLengthExpr(LengthExpr lengthExpr) {
     }.visit(tu);
   }
 
+  @Test
+  public void testLeftShiftTyped() throws Exception {
+    final TranslationUnit tu = ParseHelper.parse("#version 320 es\n"
+        + "void main() {\n"
+        + "  int a;\n"
+        + "  uint b;\n"
+        + "  ivec2 av;\n"
+        + "  uvec2 bv;\n"
+        + "\n"
+        + "  int x0 = a << a;\n"
+        + "  int x1 = a << b;\n"
+        + "  uint x2 = b << a;\n"
+        + "  uint x3 = b << b;\n"
+        + "  ivec2 x4 = av << a;\n"
+        + "  ivec2 x5 = av << b;\n"
+        + "  ivec2 x6 = av << av;\n"
+        + "  ivec2 x7 = av << bv;\n"
+        + "  uvec2 x8 = bv << a;\n"
+        + "  uvec2 x9 = bv << b;\n"
+        + "  uvec2 x10 = bv << av;\n"
+        + "  uvec2 x11 = bv << bv;\n"
+        + "}\n");
+    new NullCheckTyper(tu) {
+      private int counter = 0;
+      @Override
+      public void visitBinaryExpr(BinaryExpr binaryExpr) {
+        super.visitBinaryExpr(binaryExpr);
+        if (binaryExpr.getOp() == BinOp.SHL) {
+          switch (counter) {
+            case 0:
+            case 1:
+              assertSame(BasicType.INT, lookupType(binaryExpr));
+              break;
+            case 2:
+            case 3:
+              assertSame(BasicType.UINT, lookupType(binaryExpr));
+              break;
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+              assertSame(BasicType.IVEC2, lookupType(binaryExpr));
+              break;
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+              assertSame(BasicType.UVEC2, lookupType(binaryExpr));
+              break;
+            default:
+              fail();
+          }
+          counter++;
+        }
+      }
+    }.visit(tu);
+  }
+
+  @Test
+  public void testRightShiftTyped() throws Exception {
+    final TranslationUnit tu = ParseHelper.parse("#version 320 es\n"
+        + "void main() {\n"
+        + "  int a;\n"
+        + "  uint b;\n"
+        + "  ivec2 av;\n"
+        + "  uvec2 bv;\n"
+        + "\n"
+        + "  int x0 = a >> a;\n"
+        + "  int x1 = a >> b;\n"
+        + "  uint x2 = b >> a;\n"
+        + "  uint x3 = b >> b;\n"
+        + "  ivec2 x4 = av >> a;\n"
+        + "  ivec2 x5 = av >> b;\n"
+        + "  ivec2 x6 = av >> av;\n"
+        + "  ivec2 x7 = av >> bv;\n"
+        + "  uvec2 x8 = bv >> a;\n"
+        + "  uvec2 x9 = bv >> b;\n"
+        + "  uvec2 x10 = bv >> av;\n"
+        + "  uvec2 x11 = bv >> bv;\n"
+        + "}\n");
+    new NullCheckTyper(tu) {
+      private int counter = 0;
+      @Override
+      public void visitBinaryExpr(BinaryExpr binaryExpr) {
+        super.visitBinaryExpr(binaryExpr);
+        if (binaryExpr.getOp() == BinOp.SHR) {
+          switch (counter) {
+            case 0:
+            case 1:
+              assertSame(BasicType.INT, lookupType(binaryExpr));
+              break;
+            case 2:
+            case 3:
+              assertSame(BasicType.UINT, lookupType(binaryExpr));
+              break;
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+              assertSame(BasicType.IVEC2, lookupType(binaryExpr));
+              break;
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+              assertSame(BasicType.UVEC2, lookupType(binaryExpr));
+              break;
+            default:
+              fail();
+          }
+          counter++;
+        }
+      }
+    }.visit(tu);
+  }
+
   private void checkComputeShaderBuiltin(String builtin, String builtinConstant, BasicType baseType,
       TypeQualifier qualifier) throws IOException, ParseTimeoutException, InterruptedException,
       GlslParserException {