Add 1.1 binary reader support for bools (#753)

* Add reader support for bools

* Address clippy checks

* Address feedback - bool with other length_code is truly unreachable

Author: nirosys

src/lazy/binary/raw/v1_1/immutable_buffer.rs

@@ -229,7 +229,10 @@ impl<'a> ImmutableBuffer<'a> {
     /// read, the returned `FlexUInt`'s `size_in_bytes()` method will return `0`.
     pub fn read_value_length(self, header: Header) -> ParseResult<'a, FlexUInt> {
         let length = match header.length_type() {
-            LengthType::InOpcode(n) => FlexUInt::new(1, n as u64),
+            LengthType::InOpcode(n) => {
+                // FlexUInt represents the length, but is not physically present, hence the 0 size.
+                FlexUInt::new(0, n as u64)
+            }
             LengthType::FlexUIntFollows => {
                 let (flexuint, _) = self.read_flex_uint()?;
                 flexuint

src/lazy/binary/raw/v1_1/reader.rs

@@ -182,4 +182,22 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn bools() -> IonResult<()> {
+        let data: Vec<u8> = vec![
+            0xE0, 0x01, 0x01, 0xEA, // IVM
+            0x5E, // true
+            0x5F, // false
+        ];
+
+        let mut reader = LazyRawBinaryReader_1_1::new(&data);
+        let _ivm = reader.next()?.expect_ivm()?;
+
+        assert!(reader.next()?.expect_value()?.read()?.expect_bool()?);
+
+        assert!(!(reader.next()?.expect_value()?.read()?.expect_bool()?));
+
+        Ok(())
+    }
 }

src/lazy/binary/raw/v1_1/type_descriptor.rs

@@ -40,6 +40,7 @@ impl Opcode {
         use OpcodeType::*;
 
         let opcode_type = match (high_nibble, low_nibble) {
+            (0x5, 0xE..=0xF) => Boolean,
             (0xE, 0x0) => IonVersionMarker,
             (0xE, 0xA) => NullNull,
             (0xE, 0xC..=0xD) => Nop,
@@ -110,6 +111,7 @@ impl Header {
     pub fn length_type(&self) -> LengthType {
         use LengthType::*;
         match (self.ion_type_code, self.length_code) {
+            (OpcodeType::Boolean, 0xE..=0xF) => InOpcode(0),
             (OpcodeType::Nop, 0xC) => InOpcode(0),
             (OpcodeType::NullNull, 0xA) => InOpcode(0),
             _ => FlexUIntFollows,

src/lazy/binary/raw/v1_1/value.rs

@@ -9,7 +9,7 @@ use crate::{
             raw::{
                 v1_1::{
                     annotations_iterator::RawBinaryAnnotationsIterator_1_1,
-                    immutable_buffer::ImmutableBuffer, Header,
+                    immutable_buffer::ImmutableBuffer, Header, OpcodeType,
                 },
                 value::ValueParseResult,
             },
@@ -186,7 +186,15 @@ impl<'top> LazyRawBinaryValue_1_1<'top> {
 
     /// Helper method called by [`Self::read`]. Reads the current value as a bool.
     fn read_bool(&self) -> ValueParseResult<'top, BinaryEncoding_1_1> {
-        todo!();
+        debug_assert!(self.encoded_value.ion_type() == IonType::Bool);
+        let header = &self.encoded_value.header();
+        let representation = header.type_code();
+        let value = match (representation, header.length_code) {
+            (OpcodeType::Boolean, 0xE) => true,
+            (OpcodeType::Boolean, 0xF) => false,
+            _ => unreachable!("found a boolean value with an illegal length code."),
+        };
+        Ok(RawValueRef::Bool(value))
     }
 
     /// Helper method called by [`Self::read`]. Reads the current value as an int.