Merge pull request #51 from Cakefish/better-generic-support

Enable support for top level generic objects

Author: hazelwiss

bauble/src/context.rs

@@ -419,12 +419,12 @@ impl CtxNode {
     /// * If there are multiple entries at the same path.
     fn build_type(&mut self, id: TypeId, type_registry: &TypeRegistry) {
         let ty = type_registry.key_type(id);
-
         let node = self.build_nodes(ty.meta.path.borrow());
-        if let Some(ty) = node.reference.ty
-            && ty != id
+        if let Some(ty_id) = node.reference.ty
+            && ty_id != id
         {
-            panic!("Multiple types with the same path");
+            let path = ty.meta.path.borrow();
+            panic!("Multiple types with the same path: {path}");
         }
         node.reference.ty = Some(id);
     }
@@ -434,6 +434,7 @@ impl CtxNode {
         if node.reference.asset.is_some() {
             panic!("Multiple types with the same path");
         }
+
         node.reference.asset = Some(ty);
     }
 }

bauble/src/parse/parser.rs

@@ -216,14 +216,30 @@ pub fn parser<'a>() -> impl Parser<'a, ParserSource<'a>, ParseValues, Extra<'a>>
         .to_slice()
         .map_with(|ident: &str, e| ident.to_owned().spanned(e.span()));
 
-    let path_start = ident.then_ignore(just("::")).repeated().collect::<Vec<_>>();
-    let path_end = ident
-        .map(PathEnd::Ident)
-        .or(just("*::").ignore_then(ident).map(PathEnd::WithIdent));
-    let path = path_start
-        .map_with(|v, e| v.spanned(e.span()))
-        .then(path_end.map_with(|v, e| v.spanned(e.span())))
-        .map(|(leading, last)| Path { leading, last });
+    let mut path = chumsky::recursive::Recursive::declare();
+    let path_start;
+    let path_end;
+    path.define({
+        let ident_with_generics = ident.then(path.clone().delimited_by(just('<'), just('>')));
+
+        path_start = ident.then_ignore(just("::")).repeated().collect::<Vec<_>>();
+        path_end = ident_with_generics
+            .clone()
+            .map_with(|(ident, path), e| {
+                PathEnd::IdentGeneric(ident, Spanned::new(e.span(), Box::new(path)))
+            })
+            .or(just("*::")
+                .ignore_then(ident_with_generics)
+                .map_with(|(ident, path), e| {
+                    PathEnd::WithIdentGeneric(ident, Spanned::new(e.span(), Box::new(path)))
+                }))
+            .or(ident.map(PathEnd::Ident))
+            .or(just("*::").ignore_then(ident).map(PathEnd::WithIdent));
+        path_start
+            .map_with(|v, e| v.spanned(e.span()))
+            .then(path_end.clone().map_with(|v, e| v.spanned(e.span())))
+            .map(|(leading, last)| Path { leading, last })
+    });
 
     let uses = just("use")
         .padded_by(comments)
@@ -457,20 +473,22 @@ pub fn parser<'a>() -> impl Parser<'a, ParserSource<'a>, ParseValues, Extra<'a>>
                     |_| IndexMap::<Ident, ParseVal>::new(),
                 )));
 
-            let reference = just('$').ignore_then(path).map(|path| {
+            let reference = just('$').ignore_then(path.clone()).map(|path| {
                 // We have at least 1 element in the path.
                 Value::Ref(path)
             });
 
-            let path_p = path.padded_by(comments).padded();
+            let path_p = path.clone().padded_by(comments).padded();
 
             // Parser for tuple structs
             let unnamed_struct = path_p
+                .clone()
                 .then(tuple.clone())
                 .map(|(name, fields)| (Some(name), Value::Struct(FieldsKind::Unnamed(fields))));
 
             // Parser for structs
             let named_struct = path_p
+                .clone()
                 .then(structure.clone())
                 .map(|(name, fields)| (Some(name), Value::Struct(FieldsKind::Named(fields))));
 
@@ -503,16 +521,19 @@ pub fn parser<'a>() -> impl Parser<'a, ParserSource<'a>, ParseValues, Extra<'a>>
             // - `| Path::B`
             // - `|`
             let path_or = path_p
+                .clone()
                 .separated_by(just('|').padded_by(comments))
                 .allow_leading()
                 .at_least(2)
                 .collect()
                 .or(just('|')
-                    .ignore_then(path_p.or_not())
+                    .ignore_then(path_p.clone().or_not())
                     .map(|p| p.into_iter().collect()))
                 .map(Value::Or);
 
-            let path_value = path.map(|path: Path| (Some(path), Value::Struct(FieldsKind::Unit)));
+            let path_value = path
+                .clone()
+                .map(|path: Path| (Some(path), Value::Struct(FieldsKind::Unit)));
 
             // The start of a raw string: count the number of open braces
             let start_raw = just('{').repeated().at_least(1).count();
@@ -562,6 +583,7 @@ pub fn parser<'a>() -> impl Parser<'a, ParserSource<'a>, ParseValues, Extra<'a>>
             .boxed();
 
             let ty_specification = path
+                .clone()
                 .delimited_by(
                     just('<').padded_by(comments).padded(),
                     just('>').padded_by(comments).padded(),
@@ -625,9 +647,10 @@ pub fn parser<'a>() -> impl Parser<'a, ParserSource<'a>, ParseValues, Extra<'a>>
     uses.then(
         just("copy")
             .padded()
-            .ignore_then(binding(ident, object.clone(), path, comments))
+            .ignore_then(binding(ident, object.clone(), path.clone(), comments))
             .map(|binding| (binding, ItemType::Copy))
-            .or(binding(ident, object, path, comments).map(|binding| (binding, ItemType::Value)))
+            .or(binding(ident, object, path.clone(), comments)
+                .map(|binding| (binding, ItemType::Value)))
             .repeated()
             .collect::<Vec<_>>(),
     )

bauble/src/parse/value.rs

@@ -14,13 +14,19 @@ pub enum PathEnd {
     WithIdent(Ident),
     /// path::ident
     Ident(Ident),
+    /// path::*::ident<...>
+    WithIdentGeneric(Ident, Spanned<Box<Path>>),
+    /// path::ident<...>
+    IdentGeneric(Ident, Spanned<Box<Path>>),
 }
 
 impl fmt::Display for PathEnd {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             PathEnd::WithIdent(ident) => write!(f, "*::{ident}"),
             PathEnd::Ident(ident) => write!(f, "{ident}"),
+            PathEnd::WithIdentGeneric(ident, path) => write!(f, "*::{ident}<{path}>",),
+            PathEnd::IdentGeneric(ident, path) => write!(f, "{ident}<{path}>",),
         }
     }
 }
@@ -47,14 +53,37 @@ impl Path {
     }
 
     pub fn last_ident(&self) -> Spanned<&str> {
-        let (PathEnd::WithIdent(ident) | PathEnd::Ident(ident)) = &self.last.value;
+        let (PathEnd::WithIdent(ident)
+        | PathEnd::Ident(ident)
+        | PathEnd::IdentGeneric(ident, _)
+        | PathEnd::WithIdentGeneric(ident, _)) = &self.last.value;
 
         ident.as_ref().map(|s| s.as_str())
     }
 
     pub fn span(&self) -> crate::Span {
         crate::Span::new(self.last.span, self.leading.span.start..self.last.span.end)
     }
+
+    pub fn split_generic(&self) -> Option<(Path, &Path)> {
+        match &*self.last {
+            PathEnd::WithIdent(_) | PathEnd::Ident(_) => None,
+            PathEnd::WithIdentGeneric(ident, path) => Some((
+                Path {
+                    leading: self.leading.clone(),
+                    last: Spanned::new(self.last.span, PathEnd::WithIdent(ident.clone())),
+                },
+                path.as_ref().to_inner(),
+            )),
+            PathEnd::IdentGeneric(ident, path) => Some((
+                Path {
+                    leading: self.leading.clone(),
+                    last: Spanned::new(self.last.span, PathEnd::Ident(ident.clone())),
+                },
+                path.as_ref().to_inner(),
+            )),
+        }
+    }
 }
 
 impl fmt::Display for Path {

bauble/src/types/path.rs

@@ -425,11 +425,53 @@ impl<S: AsRef<str>> TypePath<S> {
     /// This means that:
     /// - The path is non-empty.
     /// - All the path segments are valid rust identifiers.
+    /// - May include generic arguments.
     pub fn is_representable_type(&self) -> bool {
+        let mut generic_ending = false;
         !self.is_empty()
             && self.iter().all(|part| {
+                if generic_ending {
+                    // If a generic path, must end with generic argument.
+                    return false;
+                }
+
+                let s = part.as_str();
+
+                let has_generic = s.ends_with('>');
                 let mut s = part.as_str().chars();
 
+                if has_generic {
+                    generic_ending = true;
+                    let mut delim_c = 1;
+                    let s = s.by_ref().rev().skip(1);
+                    let mut inner = String::new();
+                    for c in s {
+                        if c == '>' {
+                            delim_c += 1;
+                        }
+                        if c == '<' {
+                            delim_c -= 1;
+                        }
+
+                        if delim_c == 0 {
+                            break;
+                        }
+
+                        inner.push(c);
+                    }
+
+                    if delim_c != 0 {
+                        // no corresponding delimiter was found.
+                        return false;
+                    }
+
+                    // Assume inner argument to type are valid.
+                    let inner = TypePath::new_unchecked(inner);
+                    if !inner.is_representable_type() {
+                        return false;
+                    }
+                }
+
                 s.next()
                     .expect("Invariant, path parts aren't empty.")
                     .is_ident_start()

bauble/src/value/display.rs

@@ -715,13 +715,7 @@ impl<CTX> IndentedDisplay<CTX> for PathTreeNode {
                 w.write("}");
             }
             PathTreeEnd::Everything => w.write("*"),
-            PathTreeEnd::PathEnd(path_end) => match path_end {
-                crate::parse::PathEnd::WithIdent(s) => {
-                    w.write("*::");
-                    w.write(s);
-                }
-                crate::parse::PathEnd::Ident(s) => w.write(s),
-            },
+            PathTreeEnd::PathEnd(path_end) => w.write(&path_end.to_string()),
         }
     }
 }

bauble/src/value/symbols.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, collections::HashMap};
 
 use crate::{
-    BaubleContext,
+    BaubleContext, CustomError,
     context::PathReference,
     parse::{Path, PathEnd, PathTreeEnd, PathTreeNode},
     path::{TypePath, TypePathElem},
@@ -160,6 +160,13 @@ impl<'a> Symbols<'a> {
                         .spanned(end.span));
                     }
                 }
+                PathTreeEnd::PathEnd(PathEnd::IdentGeneric(ident, ..))
+                | PathTreeEnd::PathEnd(PathEnd::WithIdentGeneric(ident, ..)) => {
+                    return Err(ConversionError::Custom(CustomError::new(
+                        "Use cannot use generics",
+                    ))
+                    .spanned(ident.span));
+                }
             }
             Ok(())
         }
@@ -247,12 +254,84 @@ impl<'a> Symbols<'a> {
                     .map_err(|p| p.spanned(raw_path.span()))?;
                 PathKind::Direct(leading)
             }
+            PathEnd::WithIdentGeneric(ident, generic) => {
+                let generic = self.resolve_path(&generic.value)?;
+                PathKind::Indirect(
+                    leading,
+                    TypePathElem::new(format!("{ident}<{generic}>"))
+                        .map_err(|p| p.spanned(raw_path.span()))?,
+                )
+            }
+            PathEnd::IdentGeneric(ident, generic) => {
+                let generic = self.resolve_path(&generic.value)?;
+                leading
+                    .push_str(&format!("{ident}<{generic}>"))
+                    .map_err(|p| p.spanned(raw_path.span()))?;
+                PathKind::Direct(leading)
+            }
         };
         Ok(path.spanned(raw_path.span()))
     }
 
     pub fn resolve_item(&self, raw_path: &Path, ref_kind: RefKind) -> Result<Cow<PathReference>> {
-        let path = self.resolve_path(raw_path)?;
+        fn resolve_path(
+            symbols: &Symbols,
+            raw_path: &Path,
+            ref_kind: RefKind,
+        ) -> Result<Spanned<PathKind>> {
+            let raw_path_split = raw_path.split_generic();
+            let is_generic = raw_path_split.is_some();
+            let (path, &generic) = raw_path_split
+                .as_ref()
+                .map(|(l, r)| (l, r))
+                .unwrap_or((raw_path, &raw_path));
+
+            let path = symbols.resolve_path(path)?;
+
+            Ok(if matches!(ref_kind, RefKind::Type) {
+                match path.value {
+                    PathKind::Direct(type_path) => {
+                        if let Some(RefCopy::Ref(r)) = symbols.uses.get(type_path.as_str())
+                            && let Some(ty) = r.ty
+                        {
+                            let path = &symbols.ctx.type_registry().key_type(ty).meta.path;
+                            if is_generic {
+                                let generic = resolve_path(symbols, generic, ref_kind)?;
+                                PathKind::Direct(
+                                    TypePath::new(format!("{path}<{generic}>")).unwrap(),
+                                )
+                            } else {
+                                PathKind::Direct(TypePath::new(path.to_string()).unwrap())
+                            }
+                        } else if is_generic {
+                            let generic = resolve_path(symbols, generic, ref_kind)?;
+                            PathKind::Direct(
+                                TypePath::new(format!("{type_path}<{generic}>")).unwrap(),
+                            )
+                        } else {
+                            PathKind::Direct(TypePath::new(format!("{type_path}")).unwrap())
+                        }
+                    }
+                    PathKind::Indirect(type_path, type_path_elem) => {
+                        if is_generic {
+                            let generic = resolve_path(symbols, generic, ref_kind)?;
+                            PathKind::Indirect(
+                                type_path,
+                                TypePathElem::new(format!("{type_path_elem}<{generic}>")).unwrap(),
+                            )
+                        } else {
+                            PathKind::Indirect(type_path, type_path_elem)
+                        }
+                    }
+                }
+                .spanned(path.span)
+            } else {
+                path
+            })
+        }
+
+        let path = resolve_path(self, raw_path, ref_kind)?;
+
         match &path.value {
             PathKind::Direct(path) => {
                 if let Some(RefCopy::Ref(r)) = self.uses.get(path.as_str()) {

bauble_macro_util/src/lib.rs

@@ -1185,7 +1185,9 @@ pub fn derive_bauble_derive_input(
         quote! {
             ::bauble::path::TypePath::new({
                 let mut s = __generic_path.to_string();
+                s.push_str("<");
                 #types
+                s.push_str(">");
                 s
             }).unwrap()
         }