✨ Include constant int segments in interference analysis

Author: fruno-bulax

Cargo.lock

@@ -49,7 +49,7 @@ radix_trie = "0.2.1"
 # Ensuring recursive type-checking doesn't stack overflow
 stacker = "0.1.21"
 # Manipulating bit arrays
-bitvec = "1"
+bitvec = { version = "1", features = ["serde"] }
 
 async-trait.workspace = true
 base16.workspace = true

compiler-core/Cargo.toml

@@ -81,15 +81,16 @@ use crate::{
         is_prelude_module, string,
     },
 };
-use bitvec::{order::Msb0, slice::BitSlice, view::BitView};
+use bitvec::{order::Msb0, slice::BitSlice, vec::BitVec, view::BitView};
 use ecow::EcoString;
 use id_arena::{Arena, Id};
 use itertools::Itertools;
-use num_bigint::BigInt;
+use num_bigint::{BigInt, Sign};
 use num_traits::ToPrimitive;
 use radix_trie::{Trie, TrieCommon};
 use std::{
     cell::RefCell,
+    cmp::Ordering,
     collections::{HashMap, HashSet, VecDeque},
     hash::Hash,
     sync::Arc,
@@ -1212,6 +1213,11 @@ pub enum BitArrayMatchedValue {
         /// is deemed unreachable: it is the location this literal value comes
         /// from in the whole pattern.
         location: SrcSpan,
+        /// The bits representing the given literal integer, with the correct
+        /// signed- and endianness as specified in the bit array segment.
+        /// Present iff the segment has a constant size that is not greater than
+        /// [BitArrayMatchedValue::MAX_BITS_INTERFERENCE]
+        bits: Option<BitVec<u8, Msb0>>,
     },
     LiteralString {
         value: EcoString,
@@ -1229,6 +1235,12 @@ pub enum BitArrayMatchedValue {
 }
 
 impl BitArrayMatchedValue {
+    /// This is an arbitrary limit beyond which interference _may_ no longer be done.
+    /// This is necessary because people may write very silly segments like
+    /// `<<0:9_007_199_254_740_992>>`, which would allocate around a wee petabyte of memory.
+    /// Literal strings are already in memory, and thus ignore this limit.
+    const MAX_BITS_INTERFERENCE: usize = u16::MAX as usize;
+
     pub(crate) fn is_literal(&self) -> bool {
         match self {
             BitArrayMatchedValue::LiteralFloat(_)
@@ -1247,12 +1259,11 @@ impl BitArrayMatchedValue {
         match self {
             BitArrayMatchedValue::LiteralString { bytes, .. } => Some(bytes.view_bits::<Msb0>()),
             BitArrayMatchedValue::Assign { value, .. } => value.constant_bits(),
+            BitArrayMatchedValue::LiteralInt { bits, .. } => bits.as_deref(),
 
             // TODO: We could also implement the interfering optimisation for
-            // literal ints as well, but that will be a bit trickier than
-            // strings.
-            BitArrayMatchedValue::LiteralInt { .. }
-            | BitArrayMatchedValue::LiteralFloat(_)
+            // literal floats as well, but the usefulness is questionable
+            BitArrayMatchedValue::LiteralFloat(_)
             | BitArrayMatchedValue::Variable(_)
             | BitArrayMatchedValue::Discard(_) => None,
         }
@@ -1267,7 +1278,9 @@ impl BitArrayMatchedValue {
     ) -> Option<ImpossibleBitArraySegmentPattern> {
         match self {
             BitArrayMatchedValue::Assign { value, .. } => value.is_impossible_segment(read_action),
-            BitArrayMatchedValue::LiteralInt { value, location } => {
+            BitArrayMatchedValue::LiteralInt {
+                value, location, ..
+            } => {
                 let size = read_action.size.constant_bits()?.to_u32()?;
                 if representable_with_bits(value.clone(), size, read_action.signed) {
                     None
@@ -3521,6 +3534,7 @@ fn segment_matched_value(
         } => BitArrayMatchedValue::LiteralInt {
             value: int_value.clone(),
             location: *location,
+            bits: int_to_bits(int_value, &read_action.size, read_action.endianness),
         },
         ast::Pattern::Float { value, .. } => BitArrayMatchedValue::LiteralFloat(value.clone()),
         ast::Pattern::String { value, .. } if segment.has_utf16_option() => {
@@ -3558,6 +3572,80 @@ fn segment_matched_value(
     }
 }
 
+/// Convert a BigInt to its bitarray representation.
+/// Returns `None` if the read size is not constant, or if the size is larger than
+/// [BitArrayMatchedValue::MAX_BITS_INTERFERENCE]
+fn int_to_bits(
+    value: &BigInt,
+    read_size: &ReadSize,
+    endianness: Endianness,
+) -> Option<BitVec<u8, Msb0>> {
+    let size = read_size.constant_bits()?.to_usize()?;
+    if size == 0 || size > BitArrayMatchedValue::MAX_BITS_INTERFERENCE {
+        return None;
+    }
+    // Pad negative numbers with 1s (true) and non-negative numbers with 0s (false)
+    let pad_digit = value.sign() == Sign::Minus;
+
+    // There are 3 cases, which are easier to handle separately by endianness
+    // If the size of the bigint bytes equals the expected bits, we can return them as-is
+    // If there are more bits than we need, we need to trim some of the most significant bits.
+    // E.g. `6:3` yields one byte of which we need to trim the 5 most significant bits.
+    // If there are fewer bits than we need, we need to add some.
+    // E.g. `6:13` yields one byte which we need to pad with 5 bits
+    let bits = match endianness {
+        // Big endian is easier to work with as we can simply trim or pad the front
+        Endianness::Big => {
+            let bytes = value.to_signed_bytes_be();
+            let bytes_size = bytes.len() * 8;
+            match bytes_size.cmp(&size) {
+                Ordering::Greater => BitVec::from_bitslice(&bytes.view_bits()[bytes_size - size..]),
+                Ordering::Less => {
+                    let mut bits = BitVec::repeat(pad_digit, size - bytes_size);
+                    bits.extend_from_raw_slice(&bytes);
+                    bits
+                }
+                Ordering::Equal => BitVec::from_vec(bytes),
+            }
+        }
+        Endianness::Little => {
+            let mut bytes = value.to_signed_bytes_le();
+            let bytes_size = bytes.len() * 8;
+            match bytes_size.cmp(&size) {
+                Ordering::Greater => {
+                    // First truncate the trailing most significant *bytes*
+                    // E.g. truncate 0xffffff:10 to two bytes (0xffff)
+                    let required_bytes = size.div_ceil(8);
+                    bytes.truncate(required_bytes);
+
+                    let remainder = size % 8;
+                    if remainder == 0 {
+                        BitVec::from_vec(bytes)
+                    } else {
+                        // If the size is not a multiple of 8, we need to truncate the most significant bits
+                        // As they are in the last byte, we leftshift by the appropriate amount and
+                        // truncate the final bits after conversion
+                        let last_byte = bytes.last_mut().expect("bytes must not be empty");
+                        *last_byte <<= 8 - remainder;
+
+                        let mut bits = BitVec::from_vec(bytes);
+                        bits.truncate(size);
+                        bits
+                    }
+                }
+                Ordering::Less => {
+                    let mut bits = BitVec::from_vec(bytes);
+                    let padding: BitVec<u8, Msb0> = BitVec::repeat(pad_digit, size - bytes_size);
+                    bits.extend_from_bitslice(padding.as_bitslice());
+                    bits
+                }
+                Ordering::Equal => BitVec::from_vec(bytes),
+            }
+        }
+    };
+    Some(bits)
+}
+
 fn segment_size(
     segment: &TypedPatternBitArraySegment,
     pattern_variables: &HashMap<EcoString, ReadAction>,
@@ -3727,3 +3815,100 @@ mod representable_with_bits_test {
         assert!(!representable_with_bits(BigInt::from(-9), 3, true));
     }
 }
+
+#[cfg(test)]
+mod int_to_bits_test {
+    use std::assert_eq;
+
+    use crate::{
+        ast::Endianness,
+        exhaustiveness::{BitArrayMatchedValue, ReadSize, int_to_bits},
+    };
+    use bitvec::{bitvec, order::Msb0, vec::BitVec};
+    use num_bigint::BigInt;
+
+    fn read_size(size: usize) -> ReadSize {
+        ReadSize::ConstantBits(BigInt::from(size))
+    }
+
+    #[test]
+    fn int_to_bits_size_too_big() {
+        assert!(
+            int_to_bits(
+                &BigInt::ZERO,
+                &read_size(BitArrayMatchedValue::MAX_BITS_INTERFERENCE + 1),
+                Endianness::Big
+            )
+            .is_none()
+        );
+    }
+
+    #[test]
+    fn int_to_bits_zero() {
+        let expect = Some(bitvec![u8, Msb0; 0; 3]);
+        assert_eq!(
+            int_to_bits(&BigInt::ZERO, &read_size(3), Endianness::Big),
+            expect
+        );
+        assert_eq!(
+            int_to_bits(&BigInt::ZERO, &read_size(3), Endianness::Little),
+            expect
+        );
+
+        let expect = Some(bitvec![u8, Msb0; 0; 10]);
+        assert_eq!(
+            int_to_bits(&BigInt::ZERO, &read_size(10), Endianness::Big),
+            expect
+        );
+        assert_eq!(
+            int_to_bits(&BigInt::ZERO, &read_size(10), Endianness::Little),
+            expect
+        );
+    }
+
+    #[test]
+    fn int_to_bits_positive() {
+        // Exact match
+        assert_eq!(
+            int_to_bits(&BigInt::from(0xff00), &read_size(16), Endianness::Big),
+            Some(BitVec::<u8, Msb0>::from_vec(vec![0xff, 0x00])),
+        );
+        assert_eq!(
+            int_to_bits(&BigInt::from(0xff00), &read_size(16), Endianness::Little),
+            Some(BitVec::<u8, Msb0>::from_vec(vec![0x00, 0xff])),
+        );
+
+        // Too many bits in int
+        assert_eq!(
+            int_to_bits(&BigInt::from(0xff00ff), &read_size(12), Endianness::Big),
+            Some(bitvec![u8, Msb0; 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]),
+        );
+        assert_eq!(
+            int_to_bits(&BigInt::from(0xff00ff), &read_size(12), Endianness::Little),
+            Some(bitvec![u8, Msb0; 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]),
+        );
+
+        // Too few bits in int
+        assert_eq!(
+            int_to_bits(&BigInt::from(0xff), &read_size(12), Endianness::Big),
+            Some(bitvec![u8, Msb0; 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]),
+        );
+        assert_eq!(
+            int_to_bits(&BigInt::from(0xff), &read_size(12), Endianness::Little),
+            Some(bitvec![u8, Msb0; 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]),
+        );
+    }
+
+    #[test]
+    fn int_to_bits_negative() {
+        // Too few bits in int
+        assert_eq!(
+            int_to_bits(&BigInt::from(-128), &read_size(12), Endianness::Big),
+            Some(bitvec![u8, Msb0; 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]),
+        );
+        assert_eq!(
+            int_to_bits(&BigInt::from(-128), &read_size(12), Endianness::Little),
+            Some(bitvec![u8, Msb0; 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]),
+        );
+    }
+}

compiler-core/src/exhaustiveness.rs

@@ -0,0 +1,25 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\npub fn wibble(bits) {\n  case bits {\n    <<0b1:1, _:1>> -> 1\n    <<0b11:2>> -> 2\n    _ -> 3\n  }\n}"
+---
+----- SOURCE CODE
+
+pub fn wibble(bits) {
+  case bits {
+    <<0b1:1, _:1>> -> 1
+    <<0b11:2>> -> 2
+    _ -> 3
+  }
+}
+
+----- WARNING
+warning: Unreachable pattern
+  ┌─ /src/warning/wrn.gleam:5:5
+  │
+5 │     <<0b11:2>> -> 2
+  │     ^^^^^^^^^^
+
+This pattern cannot be reached as a previous pattern matches the same
+values.
+
+Hint: It can be safely removed.

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__unreachable_int_pattern_with_prefix_int.snap

@@ -0,0 +1,25 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\npub fn wibble(bits) {\n  case bits {\n    <<\"a\">> -> 1\n    <<97>> -> 2\n    _ -> 3\n  }\n}"
+---
+----- SOURCE CODE
+
+pub fn wibble(bits) {
+  case bits {
+    <<"a">> -> 1
+    <<97>> -> 2
+    _ -> 3
+  }
+}
+
+----- WARNING
+warning: Unreachable pattern
+  ┌─ /src/warning/wrn.gleam:5:5
+  │
+5 │     <<97>> -> 2
+  │     ^^^^^^
+
+This pattern cannot be reached as a previous pattern matches the same
+values.
+
+Hint: It can be safely removed.

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__unreachable_int_pattern_with_string_of_same_value.snap

@@ -4515,6 +4515,34 @@ pub fn wibble(bits) {
     );
 }
 
+#[test]
+fn unreachable_int_pattern_with_string_of_same_value() {
+    assert_warning!(
+        r#"
+pub fn wibble(bits) {
+  case bits {
+    <<"a">> -> 1
+    <<97>> -> 2
+    _ -> 3
+  }
+}"#
+    );
+}
+
+#[test]
+fn unreachable_int_pattern_with_prefix_int() {
+    assert_warning!(
+        r#"
+pub fn wibble(bits) {
+  case bits {
+    <<0b1:1, _:1>> -> 1
+    <<0b11:2>> -> 2
+    _ -> 3
+  }
+}"#
+    );
+}
+
 #[test]
 fn unused_recursive_function_argument() {
     assert_warning!(