Make signatures a little more general

src/parser/parse/parser.rs

@@ -151,7 +151,7 @@ pub fn var(input: NomSpan) -> IResult<NomSpan, TokenNode> {
     trace_step(input, "var", move |input| {
         let start = input.offset;
         let (input, _) = tag("$")(input)?;
-        let (input, bare) = identifier(input)?;
+        let (input, bare) = member(input)?;
         let end = input.offset;
 
         Ok((
@@ -161,14 +161,7 @@ pub fn var(input: NomSpan) -> IResult<NomSpan, TokenNode> {
     })
 }
 
-// let start = input.offset;
-// let (input, _) = take_while1(is_start_bare_char)(input)?;
-// let (input, _) = take_while(is_bare_char)(input)?;
-// let end = input.offset;
-
-// Ok((input, TokenTreeBuilder::spanned_bare((start, end))))
-
-pub fn identifier(input: NomSpan) -> IResult<NomSpan, TokenNode> {
+pub fn member(input: NomSpan) -> IResult<NomSpan, TokenNode> {
     trace_step(input, "identifier", move |input| {
         let start = input.offset;
         let (input, _) = take_while1(is_id_start)(input)?;
@@ -176,7 +169,7 @@ pub fn identifier(input: NomSpan) -> IResult<NomSpan, TokenNode> {
 
         let end = input.offset;
 
-        Ok((input, TokenTreeBuilder::spanned_ident((start, end))))
+        Ok((input, TokenTreeBuilder::spanned_member((start, end))))
     })
 }
 
@@ -412,7 +405,7 @@ pub fn path(input: NomSpan) -> IResult<NomSpan, TokenNode> {
         let left = input.offset;
         let (input, head) = node1(input)?;
         let (input, _) = tag(".")(input)?;
-        let (input, tail) = separated_list(tag("."), alt((identifier, string)))(input)?;
+        let (input, tail) = separated_list(tag("."), alt((member, string)))(input)?;
         let right = input.offset;
 
         Ok((
@@ -802,14 +795,14 @@ mod tests {
         let _ = pretty_env_logger::try_init();
         assert_eq!(
             apply(node, "node", "$it.print"),
-            build_token(b::path(b::var("it"), vec![b::ident("print")]))
+            build_token(b::path(b::var("it"), vec![b::member("print")]))
         );
 
         assert_eq!(
             apply(node, "node", "$head.part1.part2"),
             build_token(b::path(
                 b::var("head"),
-                vec![b::ident("part1"), b::ident("part2")]
+                vec![b::member("part1"), b::member("part2")]
             ))
         );
 
@@ -817,7 +810,7 @@ mod tests {
             apply(node, "node", "( hello ).world"),
             build_token(b::path(
                 b::parens(vec![b::sp(), b::bare("hello"), b::sp()]),
-                vec![b::ident("world")]
+                vec![b::member("world")]
             ))
         );
 
@@ -843,7 +836,7 @@ mod tests {
                     b::sp(),
                     b::path(
                         b::var("it"),
-                        vec![b::ident("is"), b::string("great news"), b::ident("right")]
+                        vec![b::member("is"), b::string("great news"), b::member("right")]
                     ),
                     b::sp(),
                     b::bare("yep"),
@@ -972,7 +965,7 @@ mod tests {
                         vec![
                             b::sp(),
                             b::braced(vec![
-                                b::path(b::var("it"), vec![b::ident("size")]),
+                                b::path(b::var("it"), vec![b::member("size")]),
                                 b::sp(),
                                 b::op(">"),
                                 b::sp(),

src/parser/parse/token_tree.rs

@@ -15,7 +15,7 @@ pub enum TokenNode {
     Pipeline(Spanned<Pipeline>),
     Operator(Spanned<Operator>),
     Flag(Spanned<Flag>),
-    Identifier(Span),
+    Member(Span),
     Whitespace(Span),
     #[allow(unused)]
     Error(Spanned<Box<ShellError>>),
@@ -92,13 +92,29 @@ impl TokenNode {
             TokenNode::Pipeline(s) => s.span,
             TokenNode::Operator(s) => s.span,
             TokenNode::Flag(s) => s.span,
-            TokenNode::Identifier(s) => *s,
+            TokenNode::Member(s) => *s,
             TokenNode::Whitespace(s) => *s,
             TokenNode::Error(s) => s.span,
             TokenNode::Path(s) => s.span,
         }
     }
 
+    pub fn type_name(&self) -> String {
+        match self {
+            TokenNode::Token(t) => t.type_name(),
+            TokenNode::Call(s) => "command",
+            TokenNode::Delimited(d) => d.type_name(),
+            TokenNode::Pipeline(s) => "pipeline",
+            TokenNode::Operator(s) => "operator",
+            TokenNode::Flag(s) => "flag",
+            TokenNode::Member(s) => "member",
+            TokenNode::Whitespace(s) => "whitespace",
+            TokenNode::Error(s) => "error",
+            TokenNode::Path(s) => "path",
+        }
+        .to_string()
+    }
+
     pub fn debug(&'a self, source: &'a Text) -> DebugTokenNode<'a> {
         DebugTokenNode { node: self, source }
     }
@@ -147,6 +163,16 @@ pub struct DelimitedNode {
     children: Vec<TokenNode>,
 }
 
+impl DelimitedNode {
+    pub fn type_name(&self) -> &'static str {
+        match self.delimiter {
+            Delimiter::Brace => "braced expression",
+            Delimiter::Paren => "parenthesized expression",
+            Delimiter::Square => "array literal or index operator",
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, FromStr)]
 pub enum Delimiter {
     Paren,

src/parser/parse/token_tree_builder.rs

@@ -266,17 +266,17 @@ impl TokenTreeBuilder {
         ))
     }
 
-    pub fn ident(input: impl Into<String>) -> CurriedToken {
+    pub fn member(input: impl Into<String>) -> CurriedToken {
         let input = input.into();
 
         Box::new(move |b| {
             let (start, end) = b.consume(&input);
-            TokenTreeBuilder::spanned_ident((start, end))
+            TokenTreeBuilder::spanned_member((start, end))
         })
     }
 
-    pub fn spanned_ident(span: impl Into<Span>) -> TokenNode {
-        TokenNode::Identifier(span.into())
+    pub fn spanned_member(span: impl Into<Span>) -> TokenNode {
+        TokenNode::Member(span.into())
     }
 
     pub fn call(head: CurriedToken, input: Vec<CurriedToken>) -> CurriedCall {