# V6069. Unsigned right shift assignment of negative 'byte' / 'short' value.

Анализатор обнаружил случай, когда над возможно отрицательным числом типа 'byte' или 'short' применяется беззнаковый сдвиг вправо с присваиванием (>>>=). Результат такого сдвига может отличаться от ожидаемого.

Часто требуется, чтобы при сдвиге вправо расширение знакового разряда не происходило, а освобождающиеся левые разряды независимо от знака старшего бита заполнялись бы нулями. С этой целью используется оператор беззнакового сдвига вправо >>>.

Также этот сдвиг можно совмещать со знаком равенства (>>>=). Однако при этом может возникнуть неочевидное поведение при использовании данного оператора с типами 'byte' или 'short'. Проблема заключается в том, что они сначала будут неявно преобразованы к типу 'int' и сдвинуты вправо, а затем обрезаны при возвращении к исходному типу.

Если Вы попробуете скомпилировать код со следующим содержимым:

    void test(byte byteValue, boolean isFlag)
    {
      ....
      if (isFlag)
      {
       byteValue = byteValue >>> 5;
      }
      ....
    }

, то получите ошибку:

    error: incompatible types:
           possible lossy conversion from int to byte
           byteValue = byteValue >>> 5;
                                 ^

Это подтверждает вышесказанные слова о расширении до 'int', и далее компилятор не даст Вам присвоить 'int' к 'byte' без явного указания. Это означает, что Вы знаете что делаете. Если скомпилировать тот же файл с небольшим исправлением:

    ....
    byteValue >>>= 5;
    ....

, то все в порядке. При выполнении этого кода произойдет расширение, смещение и сужение до исходного типа.

Из-за этого в таком сдвиге с присвоением кроется поведение, которое может не ожидаться разработчиком. В случае сдвига положительного числа будет работать так, как и ожидалось. А что с отрицательным числом?

Давайте разберем синтетический случай, когда смещается с присвоением значение -1 типа 'byte':

    byte byteValue = -1; // 0xFF or 0b1111_1111
    byteValue >>>= 4;
    assertTrue(byteValue == 0x0F); // byteValue == 0b0000_1111

Итак, разработчик думал, что у него есть 8 бит (byte), и, беззнаково смещая на 4 бита вправо, ожидает увидеть только 4 младших бита. И тут на удивление разработчика 'assertTrue' не отрабатывает!

Это происходит как раз из-за того, что 'byteValue' неявно расширяется до 'int', сдвигается и обрезается до 'byte':

    byteValue == 0xFF (byte): 11111111
    Расширение до 'int'     : 11111111 11111111 11111111 11111111
    Смещение на 4           : 00001111 11111111 11111111 11111111
    Преобразование в 'byte' : 11111111

По завершении операции может сложиться ощущение, что беззнаковый сдвиг (>>>=) работает некорректно. Но всё логично и правильно. Просто существует нюанс, который следует учитывать при работе с типами 'byte' или 'short'.