Add flag to enable/disable type reduction

Author: Genbox

Src/FastData.Generator/Framework/OutputWriter.cs

@@ -92,8 +92,8 @@ protected string GetEqualFunction(string value1, string value2, KeyType keyTypeO
 
     protected string ToValueLabel<T>(T value) => _typeMap.ToValueLabel(value); //Uses its own generics here, not TKey. We need T so we can change the type in generators
     protected string GetObjectDeclarations<TValue>() => typeof(TValue).IsPrimitive ? "" : _typeMap.GetDeclarations<TValue>(); //We don't have declarations for primitives
-    protected string GetSmallestSignedType(long value) => _typeMap.GetSmallestIntType(value);
-    protected string GetSmallestUnsignedType(long value) => _typeMap.GetSmallestUIntType((ulong)value);
+    protected string GetSmallestSignedType(long value) => _generatorConfig.TypeReductionEnabled ? _typeMap.GetSmallestIntType(value) : _typeMap.Get<int>().Name;
+    protected string GetSmallestUnsignedType(long value) => _generatorConfig.TypeReductionEnabled ? _typeMap.GetSmallestUIntType((ulong)value) : _typeMap.Get<uint>().Name;
 
     private static IEnumerable<string> GetValues(Array array, TypeMap map, Type type)
     {

Src/FastData.TestHarness.Runner/FeatureTests.cs

@@ -69,4 +69,26 @@ public async Task PrefixSuffixTrimming(ITestHarness harness, bool ignoreCase)
         int exitCode = TestHarnessRunnerHelper.RunContainsProgram(harness, spec, lookups, notPresent, className);
         TestHarnessRunnerHelper.AssertSuccessExitCode(exitCode);
     }
+
+    [Theory]
+    [ClassData(typeof(HarnessBoolTheoryData))]
+    public async Task TypeReductionEnabled(ITestHarness harness, bool typeReductionEnabled)
+    {
+        FastDataConfig config = new FastDataConfig(StructureType.HashTable)
+        {
+            TypeReductionEnabled = typeReductionEnabled
+        };
+
+        string className = $"{nameof(TypeReductionEnabled)}_{typeReductionEnabled}";
+        byte[] keys = [byte.MinValue, 1, byte.MaxValue];
+
+        string source = FastDataGenerator.Generate(keys, config, harness.CreateGenerator(className));
+        GeneratorSpec spec = new GeneratorSpec(className, source);
+
+        await TestHarnessRunnerHelper.VerifyFeatureAsync(harness, className, spec.Source);
+
+        byte[] notPresent = [2, 4];
+        int exitCode = TestHarnessRunnerHelper.RunContainsProgram(harness, spec, keys, notPresent, className);
+        TestHarnessRunnerHelper.AssertSuccessExitCode(exitCode);
+    }
 }

Src/FastData.TestHarness.Runner/Verify/Features/CPlusPlus/TypeReductionEnabled_False.verified.txt

@@ -0,0 +1,59 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#pragma once
+#include <array>
+#include <cstring>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class TypeReductionEnabled_False final {
+    struct e {
+        uint8_t key;
+        int32_t next;
+        
+        
+        e(const uint8_t key, const int32_t next)
+           : key(key), next(next) {}
+    };
+
+    static constexpr std::array<int32_t, 3> buckets = {
+        3, 2, 0
+     };
+
+    inline static const std::array<e, 3> entries = {
+        e(0, -1), e(1, -1), e(std::numeric_limits<uint8_t>::max(), 0)
+    };
+
+    static constexpr uint64_t get_hash(const uint8_t value) noexcept
+    {
+        return static_cast<uint64_t>(value);
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const uint8_t key) noexcept {
+        if (key < 0 || key > std::numeric_limits<uint8_t>::max())
+            return false;
+
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 3;
+        int32_t i = static_cast<int32_t>(buckets[index] - 1);
+
+        while (i >= 0) {
+            const auto& entry = entries[i];
+
+            if (entry.key == key)
+                return true;
+
+            i = entry.next;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 3;
+    static constexpr uint8_t min_key = 0;
+    static constexpr uint8_t max_key = std::numeric_limits<uint8_t>::max();
+};

Src/FastData.TestHarness.Runner/Verify/Features/CPlusPlus/TypeReductionEnabled_True.verified.txt

@@ -0,0 +1,59 @@
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#pragma once
+#include <array>
+#include <cstring>
+#include <cstdint>
+#include <limits>
+#include <string_view>
+
+class TypeReductionEnabled_True final {
+    struct e {
+        uint8_t key;
+        int8_t next;
+        
+        
+        e(const uint8_t key, const int8_t next)
+           : key(key), next(next) {}
+    };
+
+    static constexpr std::array<int8_t, 3> buckets = {
+        3, 2, 0
+     };
+
+    inline static const std::array<e, 3> entries = {
+        e(0, -1), e(1, -1), e(std::numeric_limits<uint8_t>::max(), 0)
+    };
+
+    static constexpr uint64_t get_hash(const uint8_t value) noexcept
+    {
+        return static_cast<uint64_t>(value);
+    }
+
+public:
+    [[nodiscard]]
+    static constexpr bool contains(const uint8_t key) noexcept {
+        if (key < 0 || key > std::numeric_limits<uint8_t>::max())
+            return false;
+
+
+        const uint64_t hash = get_hash(key);
+        const size_t index = hash % 3;
+        int8_t i = static_cast<int8_t>(buckets[index] - 1);
+
+        while (i >= 0) {
+            const auto& entry = entries[i];
+
+            if (entry.key == key)
+                return true;
+
+            i = entry.next;
+        }
+
+        return false;
+    }
+
+    static constexpr size_t item_count = 3;
+    static constexpr uint8_t min_key = 0;
+    static constexpr uint8_t max_key = std::numeric_limits<uint8_t>::max();
+};

Src/FastData.TestHarness.Runner/Verify/Features/CSharp/TypeReductionEnabled_False.verified.txt

@@ -0,0 +1,69 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class TypeReductionEnabled_False
+{
+    [StructLayout(LayoutKind.Auto)]
+    private struct E
+    {
+        internal byte Key;
+        internal int Next;
+        
+        
+        internal E(byte key, int next )
+        {
+            Key = key;
+            Next = next;
+            
+            
+        }
+    };
+
+    private static readonly int[] _buckets = new int[] {
+        3, 2, 0
+     };
+
+    private static readonly E[] _entries = {
+        new E(byte.MinValue, -1), new E(1, -1), new E(byte.MaxValue, 0)
+    };
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(byte value)
+    {
+        return (ulong)value;
+    }
+
+    
+    public static bool Contains(byte key)
+    {
+        if (key < byte.MinValue || key > byte.MaxValue)
+            return false;
+
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash % 3);
+        int i = (int)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (entry.Key == key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+    public const uint ItemCount = 3;
+    public const byte MinKey = byte.MinValue;
+    public const byte MaxKey = byte.MaxValue;
+}

Src/FastData.TestHarness.Runner/Verify/Features/CSharp/TypeReductionEnabled_True.verified.txt

@@ -0,0 +1,69 @@
+// <auto-generated />
+// This file is auto-generated. Do not edit manually.
+// Structure: HashTable
+#nullable enable
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+internal static class TypeReductionEnabled_True
+{
+    [StructLayout(LayoutKind.Auto)]
+    private struct E
+    {
+        internal byte Key;
+        internal sbyte Next;
+        
+        
+        internal E(byte key, sbyte next )
+        {
+            Key = key;
+            Next = next;
+            
+            
+        }
+    };
+
+    private static readonly sbyte[] _buckets = new sbyte[] {
+        3, 2, 0
+     };
+
+    private static readonly E[] _entries = {
+        new E(byte.MinValue, -1), new E(1, -1), new E(byte.MaxValue, 0)
+    };
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Hash(byte value)
+    {
+        return (ulong)value;
+    }
+
+    
+    public static bool Contains(byte key)
+    {
+        if (key < byte.MinValue || key > byte.MaxValue)
+            return false;
+
+
+        ulong hash = Hash(key);
+        uint index = (uint)(hash % 3);
+        sbyte i = (sbyte)(_buckets[index] - 1);
+
+        while (i >= 0)
+        {
+            ref E entry = ref _entries[i];
+
+            if (entry.Key == key)
+                return true;
+
+            i = entry.Next;
+        }
+
+        return false;
+    }
+
+    public const uint ItemCount = 3;
+    public const byte MinKey = byte.MinValue;
+    public const byte MaxKey = byte.MaxValue;
+}

Src/FastData.TestHarness.Runner/Verify/Features/Rust/TypeReductionEnabled_False.verified.txt

@@ -0,0 +1,55 @@
+//! This file is auto-generated. Do not edit manually.
+//! Structure: HashTable
+#![allow(unused_parens)]
+#![allow(missing_docs)]
+#![allow(unused_imports)]
+#![allow(unused_unsafe)]
+use std::ptr;
+
+pub struct TypeReductionEnabled_False;
+
+impl TypeReductionEnabled_False {
+    const BUCKETS: [i32; 3] = [
+        3, 2, 0
+    ];
+
+    const ENTRIES: [E; 3] = [
+        E { next: -1, key: u8::MIN }, E { next: -1, key: 1 }, E { next: 0, key: u8::MAX }
+    ];
+
+    #[inline(always)]
+    fn get_hash(value: u8) -> u64 {
+        value as u64
+    }
+
+    #[must_use]
+    pub fn contains(key: u8) -> bool {
+        if key < u8::MIN || key > u8::MAX {
+            return false;
+        }
+
+
+        let hash = unsafe { Self::get_hash(key) };
+        let index = hash % 3;
+        let mut i: i32 = (Self::BUCKETS[index as usize] as i32) - 1;
+
+        while i >= 0 {
+            let entry = &Self::ENTRIES[i as usize];
+            if entry.key == key {
+                return true;
+            }
+            i = entry.next;
+        }
+
+        false
+    }
+
+    pub const ITEM_COUNT: usize = 3;
+    pub const MIN_KEY: u8 = u8::MIN;
+    pub const MAX_KEY: u8 = u8::MAX;
+}struct E {
+    
+    next: i32,
+    key: u8,
+    
+}