Initial API commit, mostly copied from DuckASM

DuckASM was my internal API for code-generation in my JIT (DuckLogic).
The good thing is is that this project is open source!
The bad news is that the rest of DuckLogic isn't (yet).

This was the basic API I was using for static reflection,
with a little more documentation added on

I'll copy the implementation over soon

Author: Techcable

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "static-reflect"
+version = "0.1.0"
+edition = "2018"
+description = "Static type information, giving a form of compile-time reflection"
+license = "MIT"
+
+[dependencies]
+# Optional: Support for zerogc
+zerogc = { version = "0.1.3", optional = true }
+# Optional: Support for numeric traits
+num-traits = { version = "0.2.14", optional = true }
+
+[features]
+default = ["never", "builtins"]
+# Support using the never type
+never = []
+# Support the 'builtin' alternative to stdlib types
+builtins = []
+
+
+[workspace]

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Techcable (Nicholas Schlabach)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,13 @@
+static-reflect-rust
+====================
+Compile-time reflection in rust!
+
+The original use case is type-checking generated code in a JIT compiler (with zero runtime cost).
+However, other use cases are certainly possible :)
+
+Contributions are welcome!
+I'd be happy to add more features as long as they align with the general philosophy
+of compile-time reflection.
+
+Unfortunately, there is very little documentation right now.
+Hopefully that will change in the future.

src/builtins.rs

@@ -0,0 +1,125 @@
+//! Types builtin to the 'static reflection' system
+//!
+//! These are mostly FFI-safe alternatives to the standard library
+//! types.
+use std::mem::MaybeUninit;
+use crate::StaticReflect;
+
+/// A FFi-safe slice type (`&[T]`)
+/// 
+/// Unlike the rust type, this has a well-defined C representation.
+///
+/// Internally, this is just a pointer and a length.
+///
+/// ## Safety
+/// This type maintains no in variants on its internal data.
+///
+/// However, since it is meant to be used with FFI and in other
+/// unsafe situations, this is often fine.
+/// The plus side is you can transmute to/from `[usize; 2]`
+/// without fear.
+#[derive(Debug)]
+#[repr(C)]
+pub struct AsmSlice<T> {
+    /// A pointer to the start of the memory
+    ///
+    /// May never be null, unless
+    pub ptr: *mut T,
+    /// The length of the slice
+    pub len: usize
+}
+/// A clone implementation that blindly
+/// copies the underlying bytes.
+impl<T: StaticReflect> Clone for AsmSlice<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T: StaticReflect> Copy for AsmSlice<T> {}
+
+
+/// A FFI-safe UTF8 string.
+///
+/// Unlike the rust type, this has a well-defined C representation.
+///
+/// ## Safety
+/// The underlying is expected to be UTF8. However,
+/// like its [AsmSlice] counterpart, all fields are public
+/// and this type does not maintain any invariants.
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct AsmStr {
+    /// The underlying memory of the string
+    pub bytes: AsmSlice<u8>
+}
+impl AsmStr {
+    /// A pointer to the bytes of the string
+    #[inline]
+    pub fn bytes_ptr(&self) -> *mut u8 {
+        self.bytes.ptr
+    }
+    /// The length of the string in bytes
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.bytes.len
+    }
+}
+
+/// A FFI-safe alternative to Rust's [std::optional::Option].
+///
+/// Unlike the Rust type, this does not use the null-pointer
+/// optimization.
+///
+/// NOTE: This type doesn't implement Drop.
+///
+/// ## Safety
+/// This type does not enforce its safety variants,
+/// just like [AsmSlice]. However, the first field must be
+/// a valid `bool`.
+///
+/// A valid type can only be in one of two states:
+/// 1. `{present: false, value: undefined}`
+/// 2. `{present: false, value: any}`
+#[derive(Debug)]
+#[repr(C)]
+pub struct AsmOption<T> {
+    present: bool,
+    value: MaybeUninit<T>
+}
+impl<T> AsmOption<T> {
+    /// An option with no value
+    #[inline]
+    pub fn none() -> AsmOption<T> {
+        AsmOption {
+            present: false,
+            value: MaybeUninit::uninit()
+        }
+    }
+    /// An option with a value
+    #[inline]
+    pub fn some(value: T) -> AsmOption<T> {
+        AsmOption {
+            present: true,
+            value: MaybeUninit::new(value)
+        }
+    }
+    /// Assume that this option is valid
+    ///
+    /// Technically, it should already be invalid
+    /// to have undefined internals.
+    /// However, this is still unsafe as a sort of lint.
+    #[inline]
+    pub unsafe fn assume_valid(self) -> Option<T> {
+        if self.present {
+            Some(self.value.assume_init())
+        } else {
+            None
+        }
+    }
+    /// If the value of the option is present.
+    #[inline]
+    pub fn is_present(&self) -> bool {
+        self.present
+    }
+}

src/core.rs

@@ -0,0 +1,39 @@
+use crate::StaticReflect;
+use crate::types::{TypeInfo, IntSize};
+
+macro_rules! impl_primitive {
+    ($target:ty => $info:expr) => {
+        unsafe impl StaticReflect for $target {
+            const TYPE_INFO: &'static TypeInfo<'static> = &$info;
+        }
+    }
+}
+macro_rules! impl_ints {
+    ($($target:ty),*) => {
+        $(unsafe impl StaticReflect for $target {
+            #[allow(unused_comparisons)]
+            const TYPE_INFO: &'static TypeInfo<'static> = &TypeInfo::Integer {
+                size: {
+                    let size = std::mem::size_of::<$target>();
+                    match IntSize::from_bytes(size) {
+                        Ok(s) => s,
+                        Err(_) => panic!("Invalid size")
+                    }
+                },
+                signed: <$target>::MIN < 0,
+            };
+        })*
+    }
+}
+// NOTE: Pointer sized integers have machine-dependent implementation :(
+impl_ints!(u8, u16, u32, u64, i8, i16, i32, i64, usize, isize);
+
+#[cfg(feature = "builtins")]
+impl_primitive!(str => TypeInfo::Str);
+impl_primitive!(() => TypeInfo::Unit);
+unsafe impl <T: StaticReflect> StaticReflect for *mut T {
+    const TYPE_INFO: &'static TypeInfo<'static> = &TypeInfo::Pointer;
+}
+unsafe impl <T: StaticReflect> StaticReflect for *const T {
+    const TYPE_INFO: &'static TypeInfo<'static> = &TypeInfo::Pointer;
+}

src/lib.rs

@@ -0,0 +1,67 @@
+//! A system for getting static type information.
+//!
+//! This effectively gives (some) of the power of reflection
+//! without any of the runtime cost!
+//!
+//! The original use case was type-checking generated code in a JIT compiler (with zero runtime cost).
+//! However, other use cases are certainly possible :)
+//!
+//! Contributions are welcome!
+//! I'd be happy to add more features as long as they align with the general philosophy
+//! of compile-time reflection.
+#![deny(missing_docs)]
+#![feature(
+    const_fn, // We rely on const eval :(
+    const_panic, const_option, // We use Option::unwrap
+)]
+#![cfg_attr(feature = "never", feature(never_type))]
+
+#[cfg(feature = "builtins")]
+pub mod builtins;
+pub mod types;
+
+mod core;
+
+use crate::types::TypeInfo;
+
+/// The trait for types whose information can be accessed via static reflection.
+///
+/// In order to proper access any fields,
+/// the representation must be C-compatible.
+/// Otherwise, transmutes and pointer-arithmetic are
+/// pointless because they are already undefined behavior.
+///
+/// ## Safety
+/// Incorrect implementation of this trait is considered
+/// undefined behavior. All the static type information must
+/// be correct at runtime.
+/// 
+/// For example, if this type gives field information via [FieldReflect],
+/// then the field information **must** match the representation
+/// at runtime.
+/// 
+/// The advantage of this is that other crates can rely
+/// on the representation being stable (for example, JIT compilers can use it).
+/// 
+/// The type must be `#[repr(C)]` or have some other
+/// form of FFI safety.
+pub unsafe trait StaticReflect {
+    /// The static information about the type's representation
+    const TYPE_INFO: &'static TypeInfo<'static>;
+}
+
+/// A type that supports accessing its fields via reflection.
+/// 
+/// All fields are assumed to be defined in a way that is compatible
+/// with the the C ABI. In other words, the type must be `#[repr(C)]`
+///
+/// ## Safety
+/// Implementing this type incorrectly is undefined behavior.
+pub unsafe trait FieldReflect: StaticReflect {
+    /// A magic structure that can be used to access
+    /// field info by name
+    type NamedFieldInfo;
+    /// Static information on this structure's fields,
+    /// where each field's information is given by name
+    const NAMED_FIELD_INFO: Self::NamedFieldInfo;
+}