Attempts to add // math operator (#5759)

* attempts to add `div` math operator

* allows `//` to be used too

* fmt:

* clippy issue

* returns appropriate type

* returns appropriate type 2

* fmt

* ensure consistency; rename to `fdiv`

* Update parser.rs

crates/nu-parser/src/parser.rs

@@ -4086,6 +4086,7 @@ pub fn parse_operator(
         b"-" => Operator::Minus,
         b"*" => Operator::Multiply,
         b"/" => Operator::Divide,
+        b"//" => Operator::FloorDivision,
         b"in" => Operator::In,
         b"not-in" => Operator::NotIn,
         b"mod" => Operator::Modulo,

crates/nu-parser/src/type_check.rs

@@ -181,6 +181,33 @@ pub fn math_result_type(
                     )
                 }
             },
+            Operator::FloorDivision => match (&lhs.ty, &rhs.ty) {
+                (Type::Int, Type::Int) => (Type::Int, None),
+                (Type::Float, Type::Int) => (Type::Int, None),
+                (Type::Int, Type::Float) => (Type::Int, None),
+                (Type::Float, Type::Float) => (Type::Int, None),
+                (Type::Filesize, Type::Filesize) => (Type::Int, None),
+                (Type::Duration, Type::Duration) => (Type::Int, None),
+
+                (Type::Filesize, Type::Int) => (Type::Filesize, None),
+                (Type::Duration, Type::Int) => (Type::Duration, None),
+
+                (Type::Any, _) => (Type::Any, None),
+                (_, Type::Any) => (Type::Any, None),
+                _ => {
+                    *op = Expression::garbage(op.span);
+                    (
+                        Type::Any,
+                        Some(ParseError::UnsupportedOperation(
+                            op.span,
+                            lhs.span,
+                            lhs.ty.clone(),
+                            rhs.span,
+                            rhs.ty.clone(),
+                        )),
+                    )
+                }
+            },
             Operator::And | Operator::Or => match (&lhs.ty, &rhs.ty) {
                 (Type::Bool, Type::Bool) => (Type::Bool, None),