use super::{ClassName, PrimitiveType};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GenericSignature(String);
impl GenericSignature {
#[must_use]
pub fn parse(value: impl Into<String>) -> Self {
Self(value.into())
}
pub(crate) fn new(value: String) -> Self {
Self(value)
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
#[must_use]
pub fn into_string(self) -> String {
self.0
}
#[must_use]
pub fn parse_field_type(&self) -> Option<GenericType> {
let mut parser = Parser {
input: self.0.as_bytes(),
cursor: 0,
};
let ty = parser.parse_type()?;
(parser.cursor == parser.input.len()).then_some(ty)
}
#[must_use]
pub fn parse_class(&self) -> Option<GenericClassSignature> {
let mut parser = Parser {
input: self.0.as_bytes(),
cursor: 0,
};
let parameters = parser.formals()?;
let superclass = parser.class_type()?;
let mut interfaces = Vec::new();
while parser.peek().is_some() {
interfaces.push(parser.class_type()?);
}
Some(GenericClassSignature {
parameters,
superclass,
interfaces,
})
}
#[must_use]
pub fn parse_method(&self) -> Option<GenericMethodSignature> {
let mut parser = Parser {
input: self.0.as_bytes(),
cursor: 0,
};
let parameters = parser.formals()?;
parser.consume(b'(').then_some(())?;
let mut arguments = Vec::new();
while !parser.consume(b')') {
arguments.push(parser.parse_type()?);
}
let returns = if parser.consume(b'V') {
None
} else {
Some(parser.parse_type()?)
};
let mut throws = Vec::new();
while parser.consume(b'^') {
throws.push(parser.parse_type()?);
}
(parser.cursor == parser.input.len()).then_some(GenericMethodSignature {
parameters,
arguments,
returns,
throws,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GenericParameter {
pub name: String,
pub bounds: Vec<GenericType>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GenericClassSignature {
pub parameters: Vec<GenericParameter>,
pub superclass: GenericClassType,
pub interfaces: Vec<GenericClassType>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GenericMethodSignature {
pub parameters: Vec<GenericParameter>,
pub arguments: Vec<GenericType>,
pub returns: Option<GenericType>,
pub throws: Vec<GenericType>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GenericType {
Primitive(PrimitiveType),
Class(GenericClassType),
Array(Box<GenericType>),
Variable(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GenericClassType {
pub name: ClassName,
pub arguments: Vec<GenericArgument>,
pub nested: Vec<GenericClassSegment>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GenericClassSegment {
pub name: String,
pub arguments: Vec<GenericArgument>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GenericArgument {
Type(GenericType),
Wildcard(GenericWildcard),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum GenericWildcard {
Unbounded,
Extends(GenericType),
Super(GenericType),
}
struct Parser<'a> {
input: &'a [u8],
cursor: usize,
}
impl Parser<'_> {
fn peek(&self) -> Option<u8> {
self.input.get(self.cursor).copied()
}
fn class_type(&mut self) -> Option<GenericClassType> {
if !self.consume(b'L') {
return None;
}
self.parse_class()
}
fn formals(&mut self) -> Option<Vec<GenericParameter>> {
let mut parameters = Vec::new();
if !self.consume(b'<') {
return Some(parameters);
}
while !self.consume(b'>') {
let name = self.until(b':')?;
let mut bounds = Vec::new();
if self.peek() != Some(b':') {
bounds.push(self.parse_type()?);
}
while self.consume(b':') {
bounds.push(self.parse_type()?);
}
parameters.push(GenericParameter { name, bounds });
}
Some(parameters)
}
fn parse_type(&mut self) -> Option<GenericType> {
let tag = self.next()?;
Some(match tag {
b'Z' => GenericType::Primitive(PrimitiveType::Boolean),
b'B' => GenericType::Primitive(PrimitiveType::Byte),
b'C' => GenericType::Primitive(PrimitiveType::Char),
b'S' => GenericType::Primitive(PrimitiveType::Short),
b'I' => GenericType::Primitive(PrimitiveType::Int),
b'F' => GenericType::Primitive(PrimitiveType::Float),
b'J' => GenericType::Primitive(PrimitiveType::Long),
b'D' => GenericType::Primitive(PrimitiveType::Double),
b'T' => {
let name = self.until(b';')?;
self.consume(b';').then_some(GenericType::Variable(name))?
}
b'[' => GenericType::Array(Box::new(self.parse_type()?)),
b'L' => GenericType::Class(self.parse_class()?),
_ => return None,
})
}
fn parse_class(&mut self) -> Option<GenericClassType> {
let name = self.until_any(&[b'<', b'.', b';'])?;
let name = ClassName::parse(name).ok()?;
let arguments = self.parse_arguments()?;
let mut nested = Vec::new();
while self.consume(b'.') {
let name = self.until_any(&[b'<', b'.', b';'])?;
let arguments = self.parse_arguments()?;
nested.push(GenericClassSegment { name, arguments });
}
self.consume(b';').then_some(GenericClassType {
name,
arguments,
nested,
})
}
fn parse_arguments(&mut self) -> Option<Vec<GenericArgument>> {
if !self.consume(b'<') {
return Some(Vec::new());
}
let mut arguments = Vec::new();
while !self.consume(b'>') {
let argument = match self.next()? {
b'*' => GenericArgument::Wildcard(GenericWildcard::Unbounded),
b'+' => GenericArgument::Wildcard(GenericWildcard::Extends(self.parse_type()?)),
b'-' => GenericArgument::Wildcard(GenericWildcard::Super(self.parse_type()?)),
_ => {
self.cursor -= 1;
GenericArgument::Type(self.parse_type()?)
}
};
arguments.push(argument);
}
Some(arguments)
}
fn until(&mut self, terminator: u8) -> Option<String> {
self.until_any(&[terminator])
}
fn until_any(&mut self, terminators: &[u8]) -> Option<String> {
let start = self.cursor;
while let Some(byte) = self.input.get(self.cursor) {
if terminators.contains(byte) {
break;
}
self.cursor += 1;
}
(start != self.cursor)
.then(|| String::from_utf8(self.input[start..self.cursor].to_vec()).ok())?
}
fn consume(&mut self, expected: u8) -> bool {
if self.input.get(self.cursor) == Some(&expected) {
self.cursor += 1;
true
} else {
false
}
}
fn next(&mut self) -> Option<u8> {
let byte = *self.input.get(self.cursor)?;
self.cursor += 1;
Some(byte)
}
}