Date literals (#4619)

* Date literals

* update deps

* Add date+duration

crates/nu-parser/src/flatten.rs

@@ -23,6 +23,7 @@ pub enum FlatShape {
     Record,
     Block,
     Filepath,
+    DateTime,
     GlobPattern,
     Variable,
     Flag,
@@ -45,6 +46,7 @@ impl Display for FlatShape {
             FlatShape::Operator => write!(f, "shape_operator"),
             FlatShape::Signature => write!(f, "shape_signature"),
             FlatShape::String => write!(f, "shape_string"),
+            FlatShape::DateTime => write!(f, "shape_datetime"),
             FlatShape::StringInterpolation => write!(f, "shape_string_interpolation"),
             FlatShape::List => write!(f, "shape_list"),
             FlatShape::Table => write!(f, "shape_table"),
@@ -184,6 +186,9 @@ pub fn flatten_expression(
         Expr::Nothing => {
             vec![(expr.span, FlatShape::Nothing)]
         }
+        Expr::DateTime(_) => {
+            vec![(expr.span, FlatShape::DateTime)]
+        }
         Expr::Int(_) => {
             vec![(expr.span, FlatShape::Int)]
         }

crates/nu-parser/src/parser.rs

@@ -1704,6 +1704,65 @@ pub fn parse_filepath(
     }
 }
 
+/// Parse a datetime type, eg '2022-02-02'
+pub fn parse_datetime(
+    working_set: &mut StateWorkingSet,
+    span: Span,
+) -> (Expression, Option<ParseError>) {
+    trace!("parsing: datetime");
+
+    let bytes = working_set.get_span_contents(span);
+    let token = String::from_utf8_lossy(bytes).to_string();
+
+    if let Ok(datetime) = chrono::DateTime::parse_from_rfc3339(&token) {
+        return (
+            Expression {
+                expr: Expr::DateTime(datetime),
+                span,
+                ty: Type::Date,
+                custom_completion: None,
+            },
+            None,
+        );
+    }
+
+    // Just the date
+    if let Ok(datetime) = chrono::DateTime::parse_from_rfc3339(&format!("{}T00:00:00+00:00", token))
+    {
+        return (
+            Expression {
+                expr: Expr::DateTime(datetime),
+                span,
+                ty: Type::Date,
+                custom_completion: None,
+            },
+            None,
+        );
+    }
+
+    // Date and time, assume UTC
+    if let Ok(datetime) = chrono::DateTime::parse_from_rfc3339(&format!("{}+00:00", token)) {
+        return (
+            Expression {
+                expr: Expr::DateTime(datetime),
+                span,
+                ty: Type::Date,
+                custom_completion: None,
+            },
+            None,
+        );
+    }
+
+    (
+        garbage(span),
+        Some(ParseError::Mismatch(
+            "datetime".into(),
+            "non-datetime".into(),
+            span,
+        )),
+    )
+}
+
 /// Parse a duration type, eg '10day'
 pub fn parse_duration(
     working_set: &mut StateWorkingSet,
@@ -3115,6 +3174,7 @@ pub fn parse_value(
         SyntaxShape::Number => parse_number(bytes, span),
         SyntaxShape::Int => parse_int(bytes, span),
         SyntaxShape::Duration => parse_duration(working_set, span),
+        SyntaxShape::DateTime => parse_datetime(working_set, span),
         SyntaxShape::Filesize => parse_filesize(working_set, span),
         SyntaxShape::Range => parse_range(working_set, span),
         SyntaxShape::Filepath => parse_filepath(working_set, span),
@@ -3212,6 +3272,7 @@ pub fn parse_value(
                     SyntaxShape::Int,
                     SyntaxShape::Number,
                     SyntaxShape::Range,
+                    SyntaxShape::DateTime,
                     SyntaxShape::Filesize,
                     SyntaxShape::Duration,
                     SyntaxShape::Block(None),
@@ -3950,6 +4011,7 @@ pub fn discover_captures_in_expr(
             }
         }
         Expr::CellPath(_) => {}
+        Expr::DateTime(_) => {}
         Expr::ExternalCall(head, exprs) => {
             let result = discover_captures_in_expr(working_set, head, seen, seen_blocks);
             output.extend(&result);

crates/nu-parser/src/type_check.rs

@@ -31,6 +31,7 @@ pub fn math_result_type(
                 (Type::Int, Type::Float) => (Type::Float, None),
                 (Type::Float, Type::Float) => (Type::Float, None),
                 (Type::String, Type::String) => (Type::String, None),
+                (Type::Date, Type::Duration) => (Type::Date, None),
                 (Type::Duration, Type::Duration) => (Type::Duration, None),
                 (Type::Filesize, Type::Filesize) => (Type::Filesize, None),
 
@@ -69,6 +70,7 @@ pub fn math_result_type(
                 (Type::Float, Type::Int) => (Type::Float, None),
                 (Type::Int, Type::Float) => (Type::Float, None),
                 (Type::Float, Type::Float) => (Type::Float, None),
+                (Type::Date, Type::Date) => (Type::Duration, None),
                 (Type::Duration, Type::Duration) => (Type::Duration, None),
                 (Type::Filesize, Type::Filesize) => (Type::Filesize, None),