From f7379085ae54bd553d84353ca8ed4ccc2d233f17 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Fri, 24 Mar 2023 15:25:08 +0100 Subject: gccrs: libproc_macro: Add rust interface libgrust/ChangeLog: * libproc_macro/rust/bridge.rs: New file. * libproc_macro/rust/bridge/group.rs: New file. * libproc_macro/rust/bridge/ident.rs: New file. * libproc_macro/rust/bridge/literal.rs: New file. * libproc_macro/rust/bridge/punct.rs: New file. * libproc_macro/rust/bridge/span.rs: New file. * libproc_macro/rust/bridge/token_stream.rs: New file. * libproc_macro/rust/group.rs: New file. * libproc_macro/rust/ident.rs: New file. * libproc_macro/rust/lib.rs: New file. * libproc_macro/rust/literal.rs: New file. * libproc_macro/rust/punct.rs: New file. * libproc_macro/rust/span.rs: New file. * libproc_macro/rust/token_stream.rs: New file. Signed-off-by: Pierre-Emmanuel Patry --- libgrust/libproc_macro/rust/bridge.rs | 14 + libgrust/libproc_macro/rust/bridge/group.rs | 55 +++ libgrust/libproc_macro/rust/bridge/ident.rs | 68 ++++ libgrust/libproc_macro/rust/bridge/literal.rs | 401 +++++++++++++++++++++ libgrust/libproc_macro/rust/bridge/punct.rs | 37 ++ libgrust/libproc_macro/rust/bridge/span.rs | 32 ++ libgrust/libproc_macro/rust/bridge/token_stream.rs | 156 ++++++++ libgrust/libproc_macro/rust/group.rs | 88 +++++ libgrust/libproc_macro/rust/ident.rs | 67 ++++ libgrust/libproc_macro/rust/lib.rs | 198 ++++++++++ libgrust/libproc_macro/rust/literal.rs | 189 ++++++++++ libgrust/libproc_macro/rust/punct.rs | 92 +++++ libgrust/libproc_macro/rust/span.rs | 52 +++ libgrust/libproc_macro/rust/token_stream.rs | 52 +++ 14 files changed, 1501 insertions(+) create mode 100644 libgrust/libproc_macro/rust/bridge.rs create mode 100644 libgrust/libproc_macro/rust/bridge/group.rs create mode 100644 libgrust/libproc_macro/rust/bridge/ident.rs create mode 100644 libgrust/libproc_macro/rust/bridge/literal.rs create mode 100644 libgrust/libproc_macro/rust/bridge/punct.rs create mode 100644 libgrust/libproc_macro/rust/bridge/span.rs create mode 100644 libgrust/libproc_macro/rust/bridge/token_stream.rs create mode 100644 libgrust/libproc_macro/rust/group.rs create mode 100644 libgrust/libproc_macro/rust/ident.rs create mode 100644 libgrust/libproc_macro/rust/lib.rs create mode 100644 libgrust/libproc_macro/rust/literal.rs create mode 100644 libgrust/libproc_macro/rust/punct.rs create mode 100644 libgrust/libproc_macro/rust/span.rs create mode 100644 libgrust/libproc_macro/rust/token_stream.rs (limited to 'libgrust') diff --git a/libgrust/libproc_macro/rust/bridge.rs b/libgrust/libproc_macro/rust/bridge.rs new file mode 100644 index 0000000..eb7f854 --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge.rs @@ -0,0 +1,14 @@ +pub mod group; +pub mod ident; +pub mod literal; +pub mod punct; +pub mod span; +pub mod token_stream; + +extern "C" { + fn bridge__is_available() -> bool; +} + +pub fn is_available() -> bool { + unsafe { bridge__is_available() } +} diff --git a/libgrust/libproc_macro/rust/bridge/group.rs b/libgrust/libproc_macro/rust/bridge/group.rs new file mode 100644 index 0000000..83d2e06 --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge/group.rs @@ -0,0 +1,55 @@ +use bridge::span::Span; +use bridge::token_stream::TokenStream; +use std::fmt; +use Delimiter; + +#[repr(C)] +#[derive(Debug, Clone)] +pub struct Group { + delimiter: Delimiter, + stream: TokenStream, +} + +impl Group { + pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self { + Group { delimiter, stream } + } + + pub fn delimiter(&self) -> Delimiter { + self.delimiter + } + + pub fn span(&self) -> Span { + Span {} + } + + pub fn set_span(&mut self, span: Span) { + let _ = span; + } + + pub fn stream(&self) -> TokenStream { + self.stream.clone() + } +} + +impl fmt::Display for Group { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.delimiter { + Delimiter::Parenthesis => f.write_str("(")?, + Delimiter::Brace => f.write_str("{")?, + Delimiter::Bracket => f.write_str("[")?, + Delimiter::None => (), + } + + self.stream.fmt(f)?; + + match self.delimiter { + Delimiter::Parenthesis => f.write_str(")")?, + Delimiter::Brace => f.write_str("}")?, + Delimiter::Bracket => f.write_str("]")?, + Delimiter::None => (), + } + + Ok(()) + } +} diff --git a/libgrust/libproc_macro/rust/bridge/ident.rs b/libgrust/libproc_macro/rust/bridge/ident.rs new file mode 100644 index 0000000..dbfa649 --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge/ident.rs @@ -0,0 +1,68 @@ +use bridge::span::Span; +use std::convert::TryInto; +use std::ffi::c_uchar; +use std::fmt; + +extern "C" { + fn Ident__new(string: *const c_uchar, len: u64) -> Ident; + fn Ident__new_raw(string: *const c_uchar, len: u64) -> Ident; + fn Ident__drop(ident: *const Ident); + fn Ident__clone(ident: *const Ident) -> Ident; +} + +#[repr(C)] +#[derive(Debug)] +pub struct Ident { + pub(crate) is_raw: bool, + pub(crate) val: *const c_uchar, + len: u64, +} + +impl Ident { + pub fn new(string: &str, _span: Span) -> Self { + unsafe { Ident__new(string.as_ptr(), string.len().try_into().unwrap()) } + } + + pub fn new_raw(string: &str, _span: Span) -> Self { + unsafe { Ident__new_raw(string.as_ptr(), string.len().try_into().unwrap()) } + } + + pub fn span(&self) -> Span { + Span {} + } + + pub fn set_span(&mut self, span: Span) { + let _ = span; + } +} + +impl Drop for Ident { + fn drop(&mut self) { + unsafe { Ident__drop(self as *const Ident) } + } +} + +impl fmt::Display for Ident { + /// Display as lossless converted string. + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if self.is_raw { + f.write_str("r#")?; + } + fmt::Display::fmt( + unsafe { + std::str::from_utf8(std::slice::from_raw_parts( + self.val, + self.len.try_into().unwrap(), + )) + .unwrap() + }, + f, + ) + } +} + +impl Clone for Ident { + fn clone(&self) -> Self { + unsafe { Ident__clone(self as *const Ident) } + } +} diff --git a/libgrust/libproc_macro/rust/bridge/literal.rs b/libgrust/libproc_macro/rust/bridge/literal.rs new file mode 100644 index 0000000..080cc1b --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge/literal.rs @@ -0,0 +1,401 @@ +use bridge::span::Span; +use std::convert::{TryFrom, TryInto}; +use std::ffi::c_uchar; +use std::fmt; +use std::str::FromStr; +use LexError; + +extern "C" { + fn Literal__drop(literal: *const Literal); + fn Literal__string(str: *const c_uchar, len: u64) -> Literal; + fn Literal__byte_string(bytes: *const u8, len: u64) -> Literal; + fn Literal__from_string(str: *const c_uchar, len: u64, lit: *mut Literal) -> bool; +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub enum Unsigned { + Unsigned8(u8), + Unsigned16(u16), + Unsigned32(u32), + Unsigned64(u64), + // u128 is not ffi safe, hence this representation + // https://github.com/rust-lang/rust/issues/54341 + Unsigned128(u64, u64), +} + +#[repr(C)] +#[derive(Debug, Clone, Copy)] +pub enum Signed { + Signed8(i8), + Signed16(i16), + Signed32(i32), + Signed64(i64), + // i128 is not ffi safe, hence this representation + // https://github.com/rust-lang/rust/issues/54341 + Signed128(u64, u64), +} + +#[repr(C)] +#[derive(Debug)] +pub enum Literal { + /// String literal internal representation + /// + /// # Note + /// This variant is constructed through FFI + #[allow(dead_code)] + String { + data: *const c_uchar, + len: u64, + }, + /// Bytestring literal internal representation + /// + /// # Note + /// This variant is constructed through FFI + #[allow(dead_code)] + ByteString { + data: *const u8, + size: u64, + }, + Char(u32), + Unsigned(Unsigned, bool), + Signed(Signed, bool), + Usize(u64, bool), + ISize(i64, bool), + Float32(f32, bool), + Float64(f64, bool), +} + +impl Literal { + pub fn u8_suffixed(n: u8) -> Self { + Literal::Unsigned(Unsigned::Unsigned8(n), true) + } + + pub fn u16_suffixed(n: u16) -> Self { + Literal::Unsigned(Unsigned::Unsigned16(n), true) + } + + pub fn u32_suffixed(n: u32) -> Self { + Literal::Unsigned(Unsigned::Unsigned32(n), true) + } + + pub fn u64_suffixed(n: u64) -> Self { + Literal::Unsigned(Unsigned::Unsigned64(n), true) + } + + pub fn u128_suffixed(n: u128) -> Self { + Literal::Unsigned( + Unsigned::Unsigned128( + (n >> 64).try_into().unwrap(), + (n & 0xFFFFFFFFFFFFFFFF).try_into().unwrap(), + ), + true, + ) + } + + pub fn usize_suffixed(n: usize) -> Self { + Literal::Usize(n.try_into().expect("Cannot convert usize to u64"), true) + } + + pub fn i8_suffixed(n: i8) -> Self { + Literal::Signed(Signed::Signed8(n), true) + } + + pub fn i16_suffixed(n: i16) -> Self { + Literal::Signed(Signed::Signed16(n), true) + } + + pub fn i32_suffixed(n: i32) -> Self { + Literal::Signed(Signed::Signed32(n), true) + } + + pub fn i64_suffixed(n: i64) -> Self { + Literal::Signed(Signed::Signed64(n), true) + } + + pub fn i128_suffixed(n: i128) -> Self { + Literal::Signed( + Signed::Signed128( + (n >> 64).try_into().unwrap(), + (n & 0xFFFFFFFFFFFFFFFF).try_into().unwrap(), + ), + true, + ) + } + + pub fn isize_suffixed(n: isize) -> Self { + Literal::ISize(n.try_into().expect("Cannot convert isize to i64"), true) + } + + // Unsuffixed + + pub fn u8_unsuffixed(n: u8) -> Self { + Literal::Unsigned(Unsigned::Unsigned8(n), false) + } + + pub fn u16_unsuffixed(n: u16) -> Self { + Literal::Unsigned(Unsigned::Unsigned16(n), false) + } + + pub fn u32_unsuffixed(n: u32) -> Self { + Literal::Unsigned(Unsigned::Unsigned32(n), false) + } + + pub fn u64_unsuffixed(n: u64) -> Self { + Literal::Unsigned(Unsigned::Unsigned64(n), false) + } + + pub fn u128_unsuffixed(n: u128) -> Self { + Literal::Unsigned( + Unsigned::Unsigned128( + (n >> 64).try_into().unwrap(), + (n & 0xFFFFFFFFFFFFFFFF).try_into().unwrap(), + ), + false, + ) + } + + pub fn usize_unsuffixed(n: usize) -> Self { + Literal::Usize(n.try_into().expect("Cannot convert usize to u64"), false) + } + + pub fn i8_unsuffixed(n: i8) -> Self { + Literal::Signed(Signed::Signed8(n), false) + } + + pub fn i16_unsuffixed(n: i16) -> Self { + Literal::Signed(Signed::Signed16(n), false) + } + + pub fn i32_unsuffixed(n: i32) -> Self { + Literal::Signed(Signed::Signed32(n), false) + } + + pub fn i64_unsuffixed(n: i64) -> Self { + Literal::Signed(Signed::Signed64(n), false) + } + + pub fn i128_unsuffixed(n: i128) -> Self { + Literal::Signed( + Signed::Signed128( + (n >> 64).try_into().unwrap(), + (n & 0xFFFFFFFFFFFFFFFF).try_into().unwrap(), + ), + false, + ) + } + + pub fn isize_unsuffixed(n: isize) -> Self { + Literal::ISize(n.try_into().expect("Cannot convert isize to i64"), false) + } + + pub fn f32_unsuffixed(n: f32) -> Self { + Literal::Float32(n, false) + } + + pub fn f32_suffixed(n: f32) -> Self { + Literal::Float32(n, true) + } + + pub fn f64_unsuffixed(n: f64) -> Self { + Literal::Float64(n, false) + } + + pub fn f64_suffixed(n: f64) -> Self { + Literal::Float64(n, true) + } + + pub fn string(string: &str) -> Self { + unsafe { Literal__string(string.as_ptr(), string.len().try_into().unwrap()) } + } + + pub fn character(c: char) -> Self { + Literal::Char(c.into()) + } + + pub fn byte_string(bytes: &[u8]) -> Self { + unsafe { Literal__byte_string(bytes.as_ptr(), bytes.len().try_into().unwrap()) } + } + + pub fn span(&self) -> Span { + Span {} + } + + pub fn set_span(&mut self, span: Span) { + let _ = span; + } +} + +impl Drop for Literal { + fn drop(&mut self) { + match self { + Literal::String { .. } | Literal::ByteString { .. } => unsafe { + Literal__drop(self as *const Literal) + }, + _ => (), + } + } +} + +impl fmt::Display for Literal { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Literal::String { data, len } => { + let slice = + unsafe { std::slice::from_raw_parts(*data, (*len).try_into().unwrap()) }; + f.write_str("\"")?; + f.write_str(std::str::from_utf8(slice).unwrap())?; + f.write_str("\"")?; + } + Literal::ByteString { data, size } => { + f.write_str("b\"")?; + let slice = + unsafe { std::slice::from_raw_parts(*data, (*size).try_into().unwrap()) }; + for &byte in slice { + if byte != b'"' && (b' '..=b'z').contains(&byte) { + char::try_from(byte).unwrap().fmt(f)?; + } else { + write!(f, "\\x{:02x}", byte)?; + } + } + f.write_str("b\"")?; + } + Literal::Char(val) => { + let ch: char = (*val).try_into().unwrap(); + match ch { + '\'' => f.write_str("'\\''")?, + '\0' => f.write_str("'\\0'")?, + '\n' => f.write_str("'\\n'")?, + ' '..='z' => write!(f, "'{}'", ch)?, + _ => write!(f, "'\\u{:x}'", val)?, + } + } + Literal::Unsigned(val, suffixed) => match val { + Unsigned::Unsigned8(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("u8")?; + } + } + Unsigned::Unsigned16(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("u16")?; + } + } + Unsigned::Unsigned32(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("u32")?; + } + } + Unsigned::Unsigned64(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("u64")?; + } + } + Unsigned::Unsigned128(h, l) => { + ((u128::from(*h) << 64) & u128::from(*l)).fmt(f)?; + if *suffixed { + f.write_str("u128")?; + } + } + }, + Literal::Signed(val, suffixed) => match val { + Signed::Signed8(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("i8")?; + } + } + Signed::Signed16(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("i16")?; + } + } + Signed::Signed32(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("i32")?; + } + } + Signed::Signed64(val) => { + val.fmt(f)?; + if *suffixed { + f.write_str("i64")?; + } + } + Signed::Signed128(h, l) => { + ((i128::from(*h) << 64) & i128::from(*l)).fmt(f)?; + if *suffixed { + f.write_str("i128")?; + } + } + }, + Literal::Usize(val, suffixed) => { + val.fmt(f)?; + if *suffixed { + f.write_str("usize")?; + } + } + Literal::ISize(val, suffixed) => { + val.fmt(f)?; + if *suffixed { + f.write_str("isize")?; + } + } + Literal::Float32(val, suffixed) => { + val.fmt(f)?; + if *suffixed { + f.write_str("f32")?; + } + } + Literal::Float64(val, suffixed) => { + val.fmt(f)?; + if *suffixed { + f.write_str("f64")?; + } + } + } + Ok(()) + } +} + +impl FromStr for Literal { + type Err = LexError; + + fn from_str(string: &str) -> Result { + let mut lit = Literal::Char(0); + // TODO: We might want to pass a LexError by reference to retrieve + // error information + if unsafe { + Literal__from_string( + string.as_ptr(), + string.len().try_into().unwrap(), + &mut lit as *mut Literal, + ) + } { + Err(LexError) + } else { + Ok(lit) + } + } +} + +impl Clone for Literal { + fn clone(&self) -> Self { + match self { + Literal::String { data, len } => unsafe { Literal__string(*data, *len) }, + Literal::ByteString { data, size } => unsafe { Literal__byte_string(*data, *size) }, + Literal::Char(val) => Literal::Char(*val), + Literal::Unsigned(val, suffixed) => Literal::Unsigned(*val, *suffixed), + Literal::Signed(val, suffixed) => Literal::Signed(*val, *suffixed), + Literal::Usize(val, suffixed) => Literal::Usize(*val, *suffixed), + Literal::ISize(val, suffixed) => Literal::ISize(*val, *suffixed), + Literal::Float32(val, suffixed) => Literal::Float32(*val, *suffixed), + Literal::Float64(val, suffixed) => Literal::Float64(*val, *suffixed), + } + } +} diff --git a/libgrust/libproc_macro/rust/bridge/punct.rs b/libgrust/libproc_macro/rust/bridge/punct.rs new file mode 100644 index 0000000..f5f76b1 --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge/punct.rs @@ -0,0 +1,37 @@ +use bridge::span::Span; +use std::convert::TryFrom; +use std::fmt; +use Spacing; + +#[repr(C)] +#[derive(Clone, Debug)] +pub struct Punct { + pub(crate) ch: u32, + pub(crate) spacing: Spacing, +} + +impl Punct { + pub fn new(ch: char, spacing: Spacing) -> Self { + Punct { + ch: ch.into(), + spacing, + } + } + + pub fn span(&self) -> Span { + Span {} + } + + pub fn set_span(&mut self, span: Span) { + let _ = span; + } +} + +impl fmt::Display for Punct { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if let Spacing::Alone = self.spacing { + f.write_str(" ")?; + } + char::try_from(self.ch).unwrap().fmt(f) + } +} diff --git a/libgrust/libproc_macro/rust/bridge/span.rs b/libgrust/libproc_macro/rust/bridge/span.rs new file mode 100644 index 0000000..5bbdd5a --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge/span.rs @@ -0,0 +1,32 @@ +//! Bridge internal span representation and functions +//! +//! # Note +//! +//! All methods accessing source location in rust are unstable, hence this +//! implementation with an empty structure. + +#[derive(Copy, Clone, Debug)] +#[repr(C)] +pub struct Span {} + +impl Span { + pub fn call_site() -> Self { + Span {} + } + + pub fn mixed_site() -> Self { + Span {} + } + + pub fn resolved_at(&self, _other: Span) -> Self { + Span {} + } + + pub fn located_at(&self, _other: Span) -> Self { + Span {} + } + + pub fn source_text(&self) -> Option { + None + } +} diff --git a/libgrust/libproc_macro/rust/bridge/token_stream.rs b/libgrust/libproc_macro/rust/bridge/token_stream.rs new file mode 100644 index 0000000..56f6679 --- /dev/null +++ b/libgrust/libproc_macro/rust/bridge/token_stream.rs @@ -0,0 +1,156 @@ +use bridge::{group::Group, ident::Ident, literal::Literal, punct::Punct}; +use std::convert::TryInto; +use std::ffi::c_uchar; +use std::fmt; +use std::slice; +use std::str::FromStr; +use LexError; + +type ExternalTokenTree = crate::TokenTree; +type ExternalTokenStream = crate::TokenStream; + +extern "C" { + fn TokenStream__new() -> TokenStream; + fn TokenStream__with_capacity(capacity: u64) -> TokenStream; + fn TokenStream__push(stream: *mut TokenStream, tree: TokenTree); + fn TokenStream__from_string(str: *const c_uchar, len: u64, ts: *mut TokenStream) -> bool; + fn TokenStream__clone(ts: *const TokenStream) -> TokenStream; +} + +#[repr(C)] +#[derive(Clone)] +pub enum TokenTree { + Group(Group), + Ident(Ident), + Punct(Punct), + Literal(Literal), +} + +impl fmt::Display for TokenTree { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + TokenTree::Group(group) => group.fmt(f), + TokenTree::Ident(ident) => ident.fmt(f), + TokenTree::Punct(punct) => punct.fmt(f), + TokenTree::Literal(literal) => literal.fmt(f), + } + } +} + +impl From for TokenTree { + fn from(value: ExternalTokenTree) -> Self { + match value { + ExternalTokenTree::Group(g) => TokenTree::Group(g.0), + ExternalTokenTree::Ident(i) => TokenTree::Ident(i.0), + ExternalTokenTree::Punct(p) => TokenTree::Punct(p.0), + ExternalTokenTree::Literal(l) => TokenTree::Literal(l.0), + } + } +} + +#[repr(C)] +#[derive(Debug)] +pub struct TokenStream { + pub(crate) data: *const TokenTree, + pub(crate) size: u64, + capacity: u64, +} + +impl TokenStream { + pub fn new() -> Self { + unsafe { TokenStream__new() } + } + + fn with_capacity(capacity: u64) -> Self { + unsafe { TokenStream__with_capacity(capacity) } + } + + fn push(&mut self, tree: TokenTree) { + unsafe { TokenStream__push(self as *mut TokenStream, tree) } + } + + pub fn is_empty(&self) -> bool { + 0 == self.size + } + + pub fn from_iterator(it: I) -> Self + where + I: IntoIterator, + { + let it = it.into_iter(); + let mut result = TokenStream::with_capacity(it.size_hint().0.try_into().unwrap()); + for stream in it { + for item in stream.into_iter() { + result.push(item.into()); + } + } + result + } + + pub fn from_tree_iterator(it: I) -> Self + where + I: IntoIterator, + { + let it = it.into_iter(); + let mut result = TokenStream::with_capacity(it.size_hint().0.try_into().unwrap()); + for item in it { + result.push(item.into()); + } + result + } +} + +impl Extend for TokenStream { + fn extend>(&mut self, trees: I) { + for tt in trees { + self.push(tt.into()) + } + } +} + +impl Extend for TokenStream { + fn extend>(&mut self, streams: I) { + for stream in streams { + for tt in stream { + self.push(tt.into()); + } + } + } +} + +impl fmt::Display for TokenStream { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for i in unsafe { slice::from_raw_parts(self.data, self.size.try_into().unwrap()) } { + i.fmt(f)?; + match i { + TokenTree::Punct(_) => (), + _ => f.write_str(" ")?, + } + } + Ok(()) + } +} + +impl FromStr for TokenStream { + type Err = LexError; + fn from_str(string: &str) -> Result { + let mut ts = TokenStream::new(); + if unsafe { + TokenStream__from_string( + string.as_ptr(), + string.len().try_into().unwrap(), + &mut ts as *mut TokenStream, + ) + } { + Err(LexError) + } else { + Ok(ts) + } + } +} + +impl Clone for TokenStream { + fn clone(&self) -> Self { + unsafe { TokenStream__clone(self as *const TokenStream) } + } +} diff --git a/libgrust/libproc_macro/rust/group.rs b/libgrust/libproc_macro/rust/group.rs new file mode 100644 index 0000000..29bfb9d --- /dev/null +++ b/libgrust/libproc_macro/rust/group.rs @@ -0,0 +1,88 @@ +use bridge; +use std::fmt; +use Span; +use TokenStream; + +/// Describes how a sequence of token trees is delimited. +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum Delimiter { + /// The sequence is delimited by a parenthesis `(...)`. + Parenthesis, + /// The sequence is delimited by a brace `{...}`. + Brace, + /// The sequence is delimited by a bracket `[...]`. + Bracket, + /// Invisible delimiter to preserve operator priority. + None, +} + +/// A delimited token stream. +#[derive(Clone)] +pub struct Group(pub(crate) bridge::group::Group); + +impl Group { + /// Creates a new `Group`. + /// + /// # Arguments + /// + /// * `delimiter` - The delimiter surrounding the inner [`TokenStream`]. + /// * `stream` - The tokenstream for this `Group`. + pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self { + Group(bridge::group::Group::new(delimiter, stream.0)) + } + + /// Get the delimiter of the `Group`. + pub fn delimiter(&self) -> Delimiter { + self.0.delimiter() + } + + /// Get the stream of the `Group`. + /// + /// # Note + /// + /// The returned stream does not include the delimiters of this group. + pub fn stream(&self) -> TokenStream { + TokenStream(self.0.stream()) + } + + /// Get the span for the delimiters of this token stream, spanning the + /// entire group. + pub fn span(&self) -> Span { + Span(self.0.span()) + } + + /// Get the span pointing to the opening delimiter of this `Group`. + pub fn span_open(&self) -> Span { + Span(self.0.span()) + } + + /// Get the span pointing to the closing delimiter of this `Group`. + pub fn span_close(&self) -> Span { + Span(self.0.span()) + } + + /// Change the span for this `Group`'s delimiters, but not its internal + /// tokens. + /// + /// # Note + /// + /// This method will **not** set the span of all the internal tokens spanned + /// by this group, but rather it will only set the span of the delimiter + /// tokens at the level of the `Group`. + pub fn set_span(&mut self, span: Span) { + self.0.set_span(span.0) + } +} + +impl fmt::Display for Group { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl fmt::Debug for Group { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} diff --git a/libgrust/libproc_macro/rust/ident.rs b/libgrust/libproc_macro/rust/ident.rs new file mode 100644 index 0000000..809c993 --- /dev/null +++ b/libgrust/libproc_macro/rust/ident.rs @@ -0,0 +1,67 @@ +use bridge; +use std::fmt; +use Span; + +/// An identifier. +#[derive(Clone)] +pub struct Ident(pub(crate) bridge::ident::Ident); + +impl Ident { + /// Creates a new identifier. + /// + /// # Arguments + /// + /// * `string` - A valid identifier. + /// * `span` - The span of the identifier. + /// + /// # Panics + /// + /// The `string` argument must be a valid identifier permitted by the + /// language, otherwise the function will panic. + pub fn new(string: &str, span: Span) -> Self { + Ident(bridge::ident::Ident::new(string, span.0)) + } + + /// Creates a new raw identifier. + /// + /// # Arguments + /// + /// * `string` - A valid identifier. + /// * `span` - The span of the identifier. + /// + /// # Panics + /// + /// The `string` argument must be a valid identifier permitted by the + /// language. Furthermore, it should not be a keyword used in path + /// segments, otherwise this function will panic. + pub fn new_raw(string: &str, span: Span) -> Self { + Ident(bridge::ident::Ident::new_raw(string, span.0)) + } + + /// Return the span of the identifier + pub fn span(&self) -> Span { + Span(self.0.span()) + } + + /// Change the span of the identifier. + /// + /// # Arguments + /// + /// * `span` - The new span value. + pub fn set_span(&mut self, span: Span) { + self.0.set_span(span.0); + } +} + +impl fmt::Display for Ident { + /// Display as lossless converted string. + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl fmt::Debug for Ident { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} diff --git a/libgrust/libproc_macro/rust/lib.rs b/libgrust/libproc_macro/rust/lib.rs new file mode 100644 index 0000000..a1be0ac --- /dev/null +++ b/libgrust/libproc_macro/rust/lib.rs @@ -0,0 +1,198 @@ +pub use group::{Delimiter, Group}; +pub use ident::Ident; +pub use literal::Literal; +pub use punct::{Punct, Spacing}; +pub use span::Span; +use std::error; +use std::{fmt, iter, str::FromStr}; + +mod bridge; +mod group; +mod ident; +mod literal; +mod punct; +mod span; +pub mod token_stream; + +/// Determines whether proc_macro has been made accessible to the currently +/// running program. +/// +/// # Note +/// +/// This function provide a non panicking way to detect whether the API is +/// invoked from inside of a procedural macro. +pub fn is_available() -> bool { + bridge::is_available() +} + +/// A single token or a delimited sequence of token trees. +#[derive(Clone)] +pub enum TokenTree { + Group(Group), + Ident(Ident), + Punct(Punct), + Literal(Literal), +} + +type InternalTokenTree = bridge::token_stream::TokenTree; + +impl From for TokenTree { + fn from(value: InternalTokenTree) -> Self { + match value { + InternalTokenTree::Group(g) => TokenTree::Group(Group(g)), + InternalTokenTree::Ident(i) => TokenTree::Ident(Ident(i)), + InternalTokenTree::Punct(p) => TokenTree::Punct(Punct(p)), + InternalTokenTree::Literal(l) => TokenTree::Literal(Literal(l)), + } + } +} + +impl TokenTree { + /// Get the [`Span`] for this TokenTree. + pub fn span(&self) -> Span { + match self { + TokenTree::Group(group) => group.span(), + TokenTree::Ident(ident) => ident.span(), + TokenTree::Punct(punct) => punct.span(), + TokenTree::Literal(literal) => literal.span(), + } + } + + /// Set the span for this TokenTree. + /// + /// # Arguments + /// + /// * `span` - The new span value. + pub fn set_span(&mut self, span: Span) { + match self { + TokenTree::Group(group) => group.set_span(span), + TokenTree::Ident(ident) => ident.set_span(span), + TokenTree::Punct(punct) => punct.set_span(span), + TokenTree::Literal(literal) => literal.set_span(span), + } + } +} + +impl fmt::Debug for TokenTree { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + TokenTree::Group(group) => group.fmt(f), + TokenTree::Ident(ident) => ident.fmt(f), + TokenTree::Punct(punct) => punct.fmt(f), + TokenTree::Literal(literal) => literal.fmt(f), + } + } +} + +impl fmt::Display for TokenTree { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + TokenTree::Group(group) => group.fmt(f), + TokenTree::Ident(ident) => ident.fmt(f), + TokenTree::Punct(punct) => punct.fmt(f), + TokenTree::Literal(literal) => literal.fmt(f), + } + } +} + +impl From for TokenTree { + fn from(g: Group) -> Self { + TokenTree::Group(g) + } +} + +impl From for TokenTree { + fn from(i: Ident) -> Self { + TokenTree::Ident(i) + } +} + +impl From for TokenTree { + fn from(p: Punct) -> Self { + TokenTree::Punct(p) + } +} + +impl From for TokenTree { + fn from(l: Literal) -> Self { + TokenTree::Literal(l) + } +} + +/// Error returned from `from_str` functions. +#[derive(Debug)] +pub struct LexError; + +impl fmt::Display for LexError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("cannot parse string into token stream") + } +} + +impl error::Error for LexError {} + +/// An abstract sequence of token trees. +/// +/// This type provides interfaces for iterating over those token trees. This +/// is both the input and the output of `#[proc_macro]`, +/// `#[proc_macro_attribute]` and `#[proc_macro_derive]` definitions. +#[derive(Clone)] +pub struct TokenStream(bridge::token_stream::TokenStream); + +impl TokenStream { + // TODO: Add experimental API functions for this type + + /// Creates an empty `TokenStream` containing no token trees. + pub fn new() -> Self { + TokenStream(bridge::token_stream::TokenStream::new()) + } + + /// Checks if this `TokenStream` is empty. + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } +} + +impl fmt::Display for TokenStream { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl fmt::Debug for TokenStream { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl FromStr for TokenStream { + type Err = LexError; + + fn from_str(src: &str) -> Result { + bridge::token_stream::TokenStream::from_str(src).map(TokenStream) + } +} + +impl iter::FromIterator for TokenStream { + fn from_iter>(trees: I) -> Self { + TokenStream(bridge::token_stream::TokenStream::from_tree_iterator(trees)) + } +} + +impl iter::FromIterator for TokenStream { + fn from_iter>(streams: I) -> Self { + TokenStream(bridge::token_stream::TokenStream::from_iterator(streams)) + } +} + +impl Extend for TokenStream { + fn extend>(&mut self, trees: I) { + self.0.extend(trees); + } +} + +impl Extend for TokenStream { + fn extend>(&mut self, streams: I) { + self.0.extend(streams) + } +} diff --git a/libgrust/libproc_macro/rust/literal.rs b/libgrust/libproc_macro/rust/literal.rs new file mode 100644 index 0000000..171ca56 --- /dev/null +++ b/libgrust/libproc_macro/rust/literal.rs @@ -0,0 +1,189 @@ +use bridge; +use std::fmt; +use std::str::FromStr; +use LexError; +use Span; + +/// A type representing a literal value except `true` and `false`. +/// +/// This could be one of the following: +/// * literal string (`"hello"`) +/// * byte string (`b"hello"`) +/// * character (`'a'`) +/// * byte character (`b'a'`) +/// * unsuffixed integer (`42`) +/// * suffixed integer (`42u8`) +/// * unsuffixed floating point number (`1.618`) +/// * suffixed floating point number (`1.618f32`) +/// +/// # Note +/// +/// Boolean literals like `true` and `false` are `Ident`s and do not belong +/// here. +#[derive(Clone)] +pub struct Literal(pub(crate) bridge::literal::Literal); + +impl Literal { + // TODO: Add experimental API functions for this type + // TODO: Generate those constructor with 1/2 macros instead + + pub fn u8_suffixed(n: u8) -> Self { + Literal(bridge::literal::Literal::u8_suffixed(n)) + } + + pub fn u16_suffixed(n: u16) -> Self { + Literal(bridge::literal::Literal::u16_suffixed(n)) + } + + pub fn u32_suffixed(n: u32) -> Self { + Literal(bridge::literal::Literal::u32_suffixed(n)) + } + + pub fn u64_suffixed(n: u64) -> Self { + Literal(bridge::literal::Literal::u64_suffixed(n)) + } + + pub fn u128_suffixed(n: u128) -> Self { + Literal(bridge::literal::Literal::u128_suffixed(n)) + } + + pub fn usize_suffixed(n: usize) -> Self { + Literal(bridge::literal::Literal::usize_suffixed(n)) + } + + pub fn i8_suffixed(n: i8) -> Self { + Literal(bridge::literal::Literal::i8_suffixed(n)) + } + + pub fn i16_suffixed(n: i16) -> Self { + Literal(bridge::literal::Literal::i16_suffixed(n)) + } + + pub fn i32_suffixed(n: i32) -> Self { + Literal(bridge::literal::Literal::i32_suffixed(n)) + } + + pub fn i64_suffixed(n: i64) -> Self { + Literal(bridge::literal::Literal::i64_suffixed(n)) + } + + pub fn i128_suffixed(n: i128) -> Self { + Literal(bridge::literal::Literal::i128_suffixed(n)) + } + + pub fn isize_suffixed(n: isize) -> Self { + Literal(bridge::literal::Literal::isize_suffixed(n)) + } + + // Unsuffixed + + pub fn u8_unsuffixed(n: u8) -> Self { + Literal(bridge::literal::Literal::u8_unsuffixed(n)) + } + + pub fn u16_unsuffixed(n: u16) -> Self { + Literal(bridge::literal::Literal::u16_unsuffixed(n)) + } + + pub fn u32_unsuffixed(n: u32) -> Self { + Literal(bridge::literal::Literal::u32_unsuffixed(n)) + } + + pub fn u64_unsuffixed(n: u64) -> Self { + Literal(bridge::literal::Literal::u64_unsuffixed(n)) + } + + pub fn u128_unsuffixed(n: u128) -> Self { + Literal(bridge::literal::Literal::u128_unsuffixed(n)) + } + + pub fn usize_unsuffixed(n: usize) -> Self { + Literal(bridge::literal::Literal::usize_unsuffixed(n)) + } + + pub fn i8_unsuffixed(n: i8) -> Self { + Literal(bridge::literal::Literal::i8_unsuffixed(n)) + } + + pub fn i16_unsuffixed(n: i16) -> Self { + Literal(bridge::literal::Literal::i16_unsuffixed(n)) + } + + pub fn i32_unsuffixed(n: i32) -> Self { + Literal(bridge::literal::Literal::i32_unsuffixed(n)) + } + + pub fn i64_unsuffixed(n: i64) -> Self { + Literal(bridge::literal::Literal::i64_unsuffixed(n)) + } + + pub fn i128_unsuffixed(n: i128) -> Self { + Literal(bridge::literal::Literal::i128_unsuffixed(n)) + } + + pub fn isize_unsuffixed(n: isize) -> Self { + Literal(bridge::literal::Literal::isize_unsuffixed(n)) + } + + pub fn f32_unsuffixed(n: f32) -> Self { + Literal(bridge::literal::Literal::f32_unsuffixed(n)) + } + + pub fn f32_suffixed(n: f32) -> Self { + Literal(bridge::literal::Literal::f32_suffixed(n)) + } + + pub fn f64_unsuffixed(n: f64) -> Self { + Literal(bridge::literal::Literal::f64_unsuffixed(n)) + } + + pub fn f64_suffixed(n: f64) -> Self { + Literal(bridge::literal::Literal::f64_suffixed(n)) + } + + pub fn string(string: &str) -> Self { + Literal(bridge::literal::Literal::string(string)) + } + + pub fn character(c: char) -> Self { + Literal(bridge::literal::Literal::character(c)) + } + + pub fn byte_string(bytes: &[u8]) -> Self { + Literal(bridge::literal::Literal::byte_string(bytes)) + } + + /// Get the [`Span`] for this literal. + pub fn span(&self) -> Span { + Span(self.0.span()) + } + + /// Set the span for this literal. + /// + /// # Arguments + /// + /// * `span` - The new span value. + pub fn set_span(&mut self, span: Span) { + self.0.set_span(span.0); + } +} + +impl fmt::Debug for Literal { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl fmt::Display for Literal { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl FromStr for Literal { + type Err = LexError; + + fn from_str(src: &str) -> Result { + bridge::literal::Literal::from_str(src).map(Literal) + } +} diff --git a/libgrust/libproc_macro/rust/punct.rs b/libgrust/libproc_macro/rust/punct.rs new file mode 100644 index 0000000..0f7830e --- /dev/null +++ b/libgrust/libproc_macro/rust/punct.rs @@ -0,0 +1,92 @@ +use bridge; +use std::convert::TryInto; +use std::fmt; +use Span; + +/// Describes the context of a [`Punct`] relatively to the next token. +#[repr(C)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum Spacing { + /// A [`Punct`] is not immediately followed by another `Punct`. + Alone, + /// A [`Punct`] is immediately followed by another `Punct` and can be + /// combined into a multi-character operator. + Joint, +} + +/// Single punctuation character such as `+`, `-` or `#`. +/// +/// Multi-character operators like `+=` are represented as two instances of +/// `Punct` with different forms of `Spacing` returned. +#[derive(Clone)] +pub struct Punct(pub(crate) bridge::punct::Punct); + +impl Punct { + /// Creates a new `Punct` from a given character and spacing. + /// + /// # Arguments + /// + /// * `ch` - The punctuation character. + /// * `spacing` - The link between this character and the next one. + /// + /// # Panics + /// + /// This function will panic if the `ch` argument is not a valid + /// punctuation character allowed by the language. + pub fn new(ch: char, spacing: Spacing) -> Self { + Punct(bridge::punct::Punct::new(ch, spacing)) + } + + /// Get the value for this punctuation character as `char`. + pub fn as_char(&self) -> char { + self.0 + .ch + .try_into() + .expect("Cannot convert from u32 to char") + } + + /// Get the [`Spacing`] of this punctuation character, indicating whether + /// the following character can be combined into a multi-character operator + /// or not. + pub fn spacing(&self) -> Spacing { + self.0.spacing + } + + /// Get the [`Span`] for this punctuation character. + pub fn span(&self) -> Span { + Span(self.0.span()) + } + + /// Set the span for this punctuation character. + /// + /// # Arguments + /// + /// * `span` - The new span value. + pub fn set_span(&mut self, span: Span) { + self.0.set_span(span.0); + } +} + +impl fmt::Display for Punct { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl fmt::Debug for Punct { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} + +impl PartialEq for Punct { + fn eq(&self, rhs: &char) -> bool { + self.as_char() == *rhs + } +} + +impl PartialEq for char { + fn eq(&self, rhs: &Punct) -> bool { + *self == rhs.as_char() + } +} diff --git a/libgrust/libproc_macro/rust/span.rs b/libgrust/libproc_macro/rust/span.rs new file mode 100644 index 0000000..b5d573c --- /dev/null +++ b/libgrust/libproc_macro/rust/span.rs @@ -0,0 +1,52 @@ +use bridge; +use std::fmt; + +/// A region of source code along with macro expansion information. +#[derive(Copy, Clone)] +pub struct Span(pub(crate) bridge::span::Span); + +impl Span { + // TODO: Add experimental API functions for this type + + /// Creates a new span that resolves at the macro call location. + pub fn call_site() -> Self { + Span(bridge::span::Span::call_site()) + } + + /// Creates a new span that resolved sometimes at macro call site, and + /// sometimes at macro definition site. + pub fn mixed_site() -> Self { + Span(bridge::span::Span::mixed_site()) + } + + /// Creates a new span with the same line/column informations but that + /// resolve symbols as though it were at `other`. + /// + /// # Arguments + /// + /// * `other` - Other span to resolve at. + pub fn resolved_at(&self, other: Span) -> Self { + Span(self.0.resolved_at(other.0)) + } + + /// Creates a new span with the same name resolution behavior as self, but + /// with the line/column information of `other`. + /// + /// # Arguments + /// + /// * `other` - Other span containing the line/column informations to use. + pub fn located_at(&self, other: Span) -> Self { + Span(self.0.located_at(other.0)) + } + + /// Return the source text behind a span. + pub fn source_text(&self) -> Option { + self.0.source_text() + } +} + +impl fmt::Debug for Span { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.0.fmt(f) + } +} diff --git a/libgrust/libproc_macro/rust/token_stream.rs b/libgrust/libproc_macro/rust/token_stream.rs new file mode 100644 index 0000000..9333e3e --- /dev/null +++ b/libgrust/libproc_macro/rust/token_stream.rs @@ -0,0 +1,52 @@ +//! Public implementation details for the `TokenStream` type, such as iterators. +use bridge; +use std::convert::TryInto; + +use TokenStream; +use TokenTree; + +/// An iterator over [`TokenStream`]'s [`TokenTree`]s. +#[derive(Clone)] +pub struct IntoIter { + current: *const bridge::token_stream::TokenTree, + end: *const bridge::token_stream::TokenTree, +} + +impl Iterator for IntoIter { + type Item = TokenTree; + + fn next(&mut self) -> Option { + if self.current == self.end { + None + } else { + let result = self.current; + self.current = unsafe { self.current.add(1) }; + Some(unsafe { std::ptr::read(result) }.into()) + } + } + + fn size_hint(&self) -> (usize, Option) { + // TODO: I'm not a fan of those casts, once #![feature(ptr_sub_ptr)] + // is implemented we may replace this line by the following: + // self.end.sub_ptr(self.current) + let remaining = self.end as usize - self.current as usize; + (remaining, Some(remaining)) + } + + fn count(self) -> usize { + self.end as usize - self.current as usize + } +} + +impl IntoIterator for TokenStream { + type Item = TokenTree; + type IntoIter = IntoIter; + + fn into_iter(self) -> IntoIter { + let capacity = self.0.size.try_into().unwrap(); + IntoIter { + current: self.0.data, + end: unsafe { self.0.data.add(capacity) }, + } + } +} -- cgit v1.1