javap_parser.lalrpop

use crate::class_info::*;
use proc_macro2::Span;

grammar(span: Span);

pub ClassDecl: ClassDecl = {
    ReflectedClassInfo => ClassDecl::Reflected(<>),
    ClassInfoInline => ClassDecl::Specified(<>),
};

pub ClassInfo: ClassInfo = {
    ClassInfoInline
};

#[inline]
ReflectedClassInfo: ReflectedClassInfo = {
    <l:Flags> <k:ClassKind> <n:ClassName> "{" "*" "}" => ReflectedClassInfo {
        span,
        flags: l,
        name: n,
        kind: k,
    },
};

ClassName: DotId = {
    <Id> => DotId::from(<>),
    DotId => <>,
};

#[inline]
ClassInfoInline: ClassInfo = {
    Header?
    <l:Flags> <k:ClassKind> <n:ClassName>
        <g:Generics>
        <e:("extends" <Comma<ClassRef>>)?>
        <i:("implements" <Comma<ClassRef>>)?>
    "{"
        <f:Field*>
        <m:MemberFunction*>
    "}" => {
        let mut constructors = vec![];
        let mut methods = vec![];
        for member in m.into_iter() {
            match member {
                Some(MemberFunction::Constructor(c)) => constructors.push(c),
                Some(MemberFunction::Method(m)) => methods.push(m),
                None => {}
            }
        }
        ClassInfo {
            span: span,
            flags: l,
            name: n,
            kind: k,
            generics: g,
            extends: e.unwrap_or(vec![]),
            implements: i.unwrap_or(vec![]),
            constructors,
            methods,
            fields: f,
        }
    }
};

ClassKind: ClassKind = {
    "class" => ClassKind::Class,
    "interface" => ClassKind::Interface,
};

#[inline]
Generics: Vec<Generic> = {
    () => vec![],
    ("<" <Comma<Generic>> ">"),
};

Generic: Generic = {
    Id => Generic { id: <>, extends: vec![] },
    <i:Id> "extends" <b:GenericBounds> => Generic { id: i, extends: b },
};

GenericBounds: Vec<ClassRef> = {
    ClassRef => vec![<>],
    <b:GenericBounds> "&" <c:ClassRef> => {
        let mut b = b;
        b.push(c);
        b
    },
};

Header: () = r#"Compiled from "[a-zA-Z0-9_$. ]+""#;

DotId: DotId = {
    <a:Id> r"[./]" <b:ID> => a.dot(b),
    <i:DotId> r"[./]" <s:ID> => i.dot(s),
};

Id: Id = {
    <a:ID> => Id::from(a),
};

ID: &'input str = {
    <r"[a-zA-Z_$][a-zA-Z0-9_$]*">,
    "\"" <r"[a-zA-Z_$][a-zA-Z0-9_$]*"> "\"",
}

MemberFunction: Option<MemberFunction> = {
    <c:Constructor> => Some(MemberFunction::Constructor(c)),
    <m:Method> => Some(MemberFunction::Method(m)),
    <i:Initializator> => None,
}

Constructor: Constructor = {
    <f:Flags> <g:Generics> <n:DotId> "(" <a:Comma<Type>> ")" <t:Throws> ";"  => {
        Constructor { flags: f, generics: g, argument_tys: a, throws: t,  }
    }
};

MethodSig: MethodSig = {
    <g:Generics> <n:Id> "(" <a:Comma<Type>> ")" ";" => {
        MethodSig { name: n, argument_tys: a, generics: g }
    }
};

Method: Method = {
    <f:Flags> <g:Generics> <r:ReturnType> <n:Id> "(" <a:Comma<Type>> ")" <t:Throws> ";" => {
        Method { flags: f, name: n, argument_tys: a, return_ty: r, throws: t, generics: g }
    }
};

Initializator: () = {
    <Flags> "{" "}" ";" => ()
};

Field: Field = {
    <f:Flags> <t:Type> <n:Id> ";" => {
        Field { flags: f, name: n, ty: t }
    }
};

Flags: Flags = {
    <p:Privacy> => Flags::new(p),
    <f:Flags> "final" => Flags { is_final: true, ..f },
    <f:Flags> "synchronized" => Flags { is_synchronized: true, ..f },
    <f:Flags> "native" => Flags { is_native: true, ..f },
    <f:Flags> "abstract" => Flags { is_abstract: true, ..f },
    <f:Flags> "static" => Flags { is_static: true, ..f },
    <f:Flags> "default" => Flags { is_default: true, ..f },
    <f:Flags> "transient" => Flags { is_transient: true, ..f },
    <f:Flags> "volatile" => Flags { is_volatile: true, ..f },
};

Privacy: Privacy = {
    "public" => Privacy::Public,
    "protected" => Privacy::Protected,
    "private" => Privacy::Private,
    () => Privacy::Default,
};

Throws: Vec<ClassRef> = {
    () => vec![],
    "throws" <Comma1<ClassRef>>,
}

#[inline]
ReturnType: Option<Type> = {
    "void" => None,
    Type => Some(<>),
};

Type: Type = {
    <ScalarType> => Type::Scalar(<>),
    <RefType> => Type::Ref(<>),
    <Type> "..." => Type::Repeat(Arc::new(<>)),
};

ScalarType: ScalarType = {
    "byte" => ScalarType::Byte,
    "char" => ScalarType::Char,
    "short" => ScalarType::Short,
    "int" => ScalarType::Int,
    "long" => ScalarType::Long,
    "float" => ScalarType::F32,
    "double" => ScalarType::F64,
    "boolean" => ScalarType::Boolean,
};

RefType: RefType = {
    ClassRefOrId,
    <Type> "[" "]" => RefType::Array(Arc::new(<>)),
    "?" "extends" <ClassRefOrId> => RefType::Extends(Arc::new(<>)),
    "?" "super" <ClassRefOrId> => RefType::Super(Arc::new(<>)),
    "?" => RefType::Wildcard,
};

ClassRefOrId: RefType = {
    <ClassRef> => RefType::Class(<>),
    <Id> => RefType::TypeParameter(<>),
};

ClassRef: ClassRef = {
    <name:DotId> => ClassRef { name, generics: vec![] },
    <name:DotId> "<" <generics:Comma<RefType>> ">" => ClassRef { <> },
};

Comma<E>: Vec<E> = {
    () => vec![],
    Comma1<E>,
};

Comma1<E>: Vec<E> = {
    E => vec![<>],
    <v:Comma<E>> "," <e:E> => {
        let mut v = v;
        v.push(e);
        v
    }
}