Parse tuples and more

Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
+resolver = "2"
 members = [
   "reptr",
   "dart-parser",

dart-parser/src/dart/class.rs

@@ -16,6 +16,8 @@ pub struct Class<'s> {
     pub with: Vec<NotFuncType<'s>>,
     /// Interfaces.
     pub implements: Vec<NotFuncType<'s>>,
+    /// Types a mix-in can be added to.
+    pub mixin_on: Vec<NotFuncType<'s>>,
     pub body: Vec<WithMeta<'s, ClassMember<'s>>>,
 }
 

dart-parser/src/dart/ty.rs

@@ -4,7 +4,7 @@ use super::{func_like::FuncParams, TypeParam};
 pub enum Type<'s> {
     NotFunc(NotFuncType<'s>),
     Func(Box<FuncType<'s>>),
-    Tuple(Vec<Type<'s>>),
+    Tuple(Tuple<'s>),
 }
 
 impl<'s> Type<'s> {
@@ -67,3 +67,12 @@ pub struct FuncTypeParamNamed<'s> {
     pub param_type: Type<'s>,
     pub name: &'s str,
 }
+
+#[derive(PartialEq, Eq, Debug)]
+pub struct Tuple<'s> {
+    /// A name can be specified for a positional tuple parameter,
+    /// but has no meaning whatsoever.
+    pub params_pos: Vec<FuncTypeParamPos<'s>>,
+    pub params_named: Vec<FuncTypeParamNamed<'s>>,
+    pub is_nullable: bool,
+}

dart-parser/src/parser.rs

@@ -8,6 +8,7 @@ mod expr;
 mod extension;
 mod func_call;
 mod func_like;
+mod maybe_required;
 mod meta;
 mod string;
 mod ty;
@@ -137,6 +138,7 @@ mod tests {
                         extends: None,
                         with: Vec::new(),
                         implements: Vec::default(),
+                        mixin_on: Vec::default(),
                         body: vec![
                             WithMeta::value(ClassMember::Constructor(Constructor {
                                 modifier: None,
@@ -192,6 +194,7 @@ mod tests {
                                 },
                                 NotFuncType::name("C")
                             ],
+                            mixin_on: Vec::default(),
                             body: vec![WithMeta::value(ClassMember::Var(Var {
                                 modifiers: VarModifierSet::default(),
                                 var_type: Some(Type::NotFunc(NotFuncType::name("String"))),

dart-parser/src/parser/annotation.rs

@@ -9,7 +9,7 @@ use nom::{
 
 use crate::dart::Annotation;
 
-use super::{func_call::func_call, ty::identifier, PResult};
+use super::{func_call::annotation_func_call, ty::identifier, PResult};
 
 pub fn annotation<'s, E>(s: &'s str) -> PResult<Annotation, E>
 where
@@ -20,7 +20,7 @@ where
         preceded(
             tag("@"),
             cut(alt((
-                func_call.map(Annotation::FuncCall),
+                annotation_func_call.map(Annotation::FuncCall),
                 identifier.map(Annotation::Ident),
             ))),
         ),

dart-parser/src/parser/class.rs

@@ -37,16 +37,18 @@ where
             opt(terminated(extends_clause, opt(spbr))),
             opt(terminated(with_clause, opt(spbr))),
             opt(terminated(implements_clause, opt(spbr))),
+            opt(terminated(mixin_on_clause, opt(spbr))),
             class_body,
         ))
         .map(
-            |(modifiers, name, type_params, extends, with, implements, body)| Class {
+            |(modifiers, name, type_params, extends, with, implements, on, body)| Class {
                 modifiers,
                 name,
                 type_params: type_params.unwrap_or(Vec::new()),
                 extends,
                 with: with.unwrap_or(Vec::new()),
                 implements: implements.unwrap_or(Vec::new()),
+                mixin_on: on.unwrap_or(Vec::new()),
                 body,
             },
         ),
@@ -94,10 +96,26 @@ where
     context(
         "implements_clause",
         preceded(
-            pair(tag("implements"), spbr),
+            pair(tag("implements"), spbrc),
             cut(separated_list1(
-                tuple((opt(spbr), tag(","), opt(spbr))),
-                not_func_type,
+                pair(tag(","), opt(spbrc)),
+                terminated(not_func_type, opt(spbrc)),
+            )),
+        ),
+    )(s)
+}
+
+pub fn mixin_on_clause<'s, E>(s: &'s str) -> PResult<Vec<NotFuncType>, E>
+where
+    E: ParseError<&'s str> + ContextError<&'s str>,
+{
+    context(
+        "mixin_on_clause",
+        preceded(
+            pair(tag("on"), spbrc),
+            cut(separated_list1(
+                pair(tag(","), opt(spbrc)),
+                terminated(not_func_type, opt(spbrc)),
             )),
         ),
     )(s)
@@ -235,9 +253,9 @@ mod tests {
     #[test]
     fn implements_test() {
         assert_eq!(
-            implements_clause::<VerboseError<_>>("implements A, B, C "),
+            implements_clause::<VerboseError<_>>("implements A, B, C x"),
             Ok((
-                " ",
+                "x",
                 vec![
                     NotFuncType::name("A"),
                     NotFuncType::name("B"),
@@ -271,6 +289,7 @@ mod tests {
                     extends: Some(NotFuncType::name("Base")),
                     with: Vec::new(),
                     implements: vec![NotFuncType::name("A"), NotFuncType::name("B")],
+                    mixin_on: Vec::default(),
                     body: Vec::new(),
                 }
             ))
@@ -290,6 +309,7 @@ mod tests {
                     extends: None,
                     with: Vec::new(),
                     implements: Vec::new(),
+                    mixin_on: Vec::default(),
                     body: vec![WithMeta::new(
                         vec![Meta::Annotation(Annotation::Ident("override"))],
                         ClassMember::Var(Var {
@@ -329,6 +349,7 @@ mod tests {
                         })],
                         is_nullable: false,
                     }],
+                    mixin_on: Vec::default(),
                     body: Vec::new(),
                 }
             ))

dart-parser/src/parser/enum_ty.rs

@@ -26,8 +26,8 @@ where
     context(
         "enum_ty",
         tuple((
-            terminated(preceded(pair(tag("enum"), spbr), identifier), opt(spbr)),
-            opt(terminated(implements_clause, opt(spbr))),
+            terminated(preceded(pair(tag("enum"), spbrc), identifier), opt(spbr)),
+            opt(terminated(implements_clause, opt(spbrc))),
             enum_body,
         )),
     )
@@ -53,11 +53,14 @@ where
             pair(tag("{"), opt(spbr)),
             cut(terminated(
                 pair(
-                    sep_list(
-                        0,
-                        SepMode::AllowTrailing,
-                        pair(tag(","), opt(spbr)),
-                        terminated(with_meta(enum_value), opt(spbrc)),
+                    terminated(
+                        sep_list(
+                            0,
+                            SepMode::AllowTrailing,
+                            pair(tag(","), opt(spbr)),
+                            terminated(with_meta(enum_value), opt(spbrc)),
+                        ),
+                        opt(spbrc),
                     ),
                     alt((
                         preceded(

dart-parser/src/parser/expr.rs

@@ -23,15 +23,18 @@ pub fn expr<'s, E>(s: &'s str) -> PResult<Expr, E>
 where
     E: ParseError<&'s str> + ContextError<&'s str>,
 {
-    recognize(
-        // Make sure something other than whitespace is consumed
-        preceded(opt(spbr), expr_body),
+    context(
+        "expr",
+        recognize(
+            // Make sure something other than whitespace is consumed
+            preceded(opt(spbr), expr_body),
+        )
+        .and_then(alt((
+            terminated(identifier, eof).map(Expr::Ident),
+            terminated(string, eof).map(Expr::String),
+            |s: &'s str| Ok((&s[s.len()..], Expr::Verbatim(s))),
+        ))),
     )
-    .and_then(alt((
-        terminated(identifier, eof).map(Expr::Ident),
-        terminated(string, eof).map(Expr::String),
-        |s: &'s str| Ok((&s[s.len()..], Expr::Verbatim(s))),
-    )))
     .parse(s)
 }
 

dart-parser/src/parser/func_call.rs

@@ -10,23 +10,39 @@ use nom::{
 use crate::dart::func_call::{FuncArg, FuncCall};
 
 use super::{
-    common::{sep_list, spbr, SepMode},
+    common::{sep_list, spbr, spbrc, SepMode},
     expr::expr,
     ty::{identifier, not_func_type},
     PResult,
 };
 
-pub fn func_call<'s, E>(s: &'s str) -> PResult<FuncCall, E>
+pub fn _func_call<'s, E>(s: &'s str) -> PResult<FuncCall, E>
 where
     E: ParseError<&'s str> + ContextError<&'s str>,
 {
     context(
         "func_call",
-        pair(terminated(not_func_type, opt(spbr)), func_args)
+        pair(terminated(not_func_type, opt(spbrc)), func_args)
             .map(|(ident, args)| FuncCall { ident, args }),
     )(s)
 }
 
+/// In function/constructor-call annotations whitespace is not allowed in front
+/// of the parentheses grouping the call arguments.
+///
+/// When an annotation is applied to a function declaration, this helps
+/// differentiating between the annotation arguments and the return type of the
+/// annotated function (which may be a tuple).
+pub fn annotation_func_call<'s, E>(s: &'s str) -> PResult<FuncCall, E>
+where
+    E: ParseError<&'s str> + ContextError<&'s str>,
+{
+    context(
+        "func_call",
+        pair(not_func_type, func_args).map(|(ident, args)| FuncCall { ident, args }),
+    )(s)
+}
+
 pub fn func_args<'s, E>(s: &'s str) -> PResult<Vec<FuncArg>, E>
 where
     E: ParseError<&'s str> + ContextError<&'s str>,
@@ -54,7 +70,7 @@ where
 {
     alt((
         pair(
-            terminated(identifier, tuple((opt(spbr), tag(":"), opt(spbr)))),
+            terminated(identifier, tuple((opt(spbrc), tag(":"), opt(spbrc)))),
             expr,
         )
         .map(|(name, value)| FuncArg {
@@ -76,7 +92,7 @@ mod tests {
     #[test]
     fn func_call_simple_test() {
         assert_eq!(
-            func_call::<VerboseError<_>>("f() x"),
+            _func_call::<VerboseError<_>>("f() x"),
             Ok((
                 " x",
                 FuncCall {
@@ -90,7 +106,7 @@ mod tests {
     #[test]
     fn func_call_mixed_test() {
         assert_eq!(
-            func_call::<VerboseError<_>>("f<int>(1, named: two, verbatim: 1 + 2) x"),
+            _func_call::<VerboseError<_>>("f<int>(1, named: two, verbatim: 1 + 2) x"),
             Ok((
                 " x",
                 FuncCall {