Feature: Len #441 (#545)

Co-authored-by: Daniele Scasciafratte <[email protected]>

src/modules/builtin/len.rs

@@ -0,0 +1,75 @@
+use crate::docs::module::DocumentationModule;
+use crate::modules::expression::expr::Expr;
+use crate::modules::expression::unop::UnOp;
+use crate::modules::types::{Type, Typed};
+use crate::translate::module::TranslateModule;
+use crate::utils::{ParserMetadata, TranslateMetadata};
+use heraclitus_compiler::prelude::*;
+
+#[derive(Debug, Clone)]
+pub struct Len {
+    value: Box<Expr>,
+}
+
+impl Typed for Len {
+    fn get_type(&self) -> Type {
+        Type::Num
+    }
+}
+
+impl UnOp for Len {
+    fn set_expr(&mut self, expr: Expr) {
+        self.value = Box::new(expr);
+    }
+
+    fn parse_operator(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+        token(meta, "len")?;
+        Ok(())
+    }
+}
+
+impl SyntaxModule<ParserMetadata> for Len {
+    syntax_name!("Length");
+
+    fn new() -> Self {
+        Len {
+            value: Box::new(Expr::new()),
+        }
+    }
+
+    fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+        if !matches!(self.value.get_type(), Type::Text | Type::Array(_)) {
+            let msg = self
+                .value
+                .get_error_message(meta)
+                .message("Length can only be applied to text or array types");
+            return Err(Failure::Loud(msg));
+        }
+        Ok(())
+    }
+}
+
+impl TranslateModule for Len {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
+        let value = self.value.translate(meta);
+        if self.value.get_type() == Type::Text {
+            meta.stmt_queue.push_back(format!("__AMBER_LEN={value}"));
+            return String::from("\"${#__AMBER_LEN}\"")
+        }
+        // Case for Array passed as a reference
+        if value.starts_with("\"${!") {
+                meta.stmt_queue.push_back(format!("__AMBER_LEN=({value})"));
+                String::from("\"${#__AMBER_LEN[@]}\"")
+        } else {
+            format!("\"${{#{}", value.trim_start_matches("\"${"))
+                .trim_end()
+                .to_string()
+        }
+    }
+}
+
+impl DocumentationModule for Len {
+    fn document(&self, _meta: &ParserMetadata) -> String {
+        "".to_string()
+    }
+}

src/modules/builtin/mod.rs

@@ -3,3 +3,4 @@ pub mod echo;
 pub mod mv;
 pub mod nameof;
 pub mod exit;
+pub mod len;

src/modules/expression/expr.rs

@@ -1,5 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::docs::module::DocumentationModule;
+use crate::modules::builtin::len::Len;
 use crate::modules::command::cmd::Command;
 use crate::modules::expression::binop::BinOp;
 use crate::modules::types::{Typed, Type};
@@ -79,6 +80,7 @@ pub enum ExprType {
     Cast(Cast),
     Status(Status),
     Nameof(Nameof),
+    Len(Len),
     Is(Is),
 }
 
@@ -143,11 +145,11 @@ impl SyntaxModule<ParserMetadata> for Expr {
             addition @ BinOp => [ Add, Sub ],
             multiplication @ BinOp => [ Mul, Div, Modulo ],
             types @ TypeOp => [ Is, Cast ],
-            unops @ UnOp => [ Neg, Not ],
+            unops @ UnOp => [ Neg, Not, Len ],
             literals @ Literal => [
                 // Literals
                 Parentheses, Bool, Number, Text,
-                Array, Null, Nameof, Status,
+                Array, Null, Status, Nameof,
                 // Function invocation
                 FunctionInvocation, Command,
                 // Variable access
@@ -173,9 +175,10 @@ impl TranslateModule for Expr {
             // Binary operators
             Range, Cast, Is,
             // Unary operators
-            Not, Neg, Nameof,
+            Not, Neg, Nameof, Len,
             // Literals
-            Parentheses, Bool, Number, Text, Array, Null, Status,
+            Parentheses, Bool, Number, Text,
+            Array, Null, Status,
             // Function invocation
             FunctionInvocation, Command,
             // Variable access
@@ -198,9 +201,10 @@ impl DocumentationModule for Expr {
             // Binary operators
             Range, Cast, Is,
             // Unary operators
-            Not, Neg, Nameof,
+            Not, Neg, Nameof, Len,
             // Literals
-            Parentheses, Bool, Number, Text, Array, Null, Status,
+            Parentheses, Bool, Number, Text,
+            Array, Null, Status,
             // Function invocation
             FunctionInvocation, Command,
             // Variable access

src/modules/variable/mod.rs

@@ -32,7 +32,8 @@ pub fn variable_name_keywords() -> Vec<&'static str> {
         // Command Modifiers
         "silent", "trust",
         // Misc
-        "echo", "status", "nameof", "mv", "cd", "exit",
+        "echo", "status", "nameof", "mv", "cd",
+        "exit", "len",
     ]
 }
 

src/std/fs.ab

@@ -1,4 +1,4 @@
-import { join, len, replace_regex, split } from "std/text"
+import { join, replace_regex, split } from "std/text"
 
 /// Checks if a directory exists.
 pub fun dir_exist(path) {

src/std/text.ab

@@ -91,17 +91,6 @@ pub fun chars(text: Text): [Text] {
     return chars
 }
 
-/// Gets the length of provided text or array.
-#[allow_absurd_cast]
-pub fun len(value): Num {
-    trust {
-        if value is Text:
-            return $ echo "\$\{#{nameof value}}" $ as Num
-        else:
-            return $ echo "\$\{#{nameof value}[@]}" $ as Num
-    }
-}
-
 /// Checks if some text contains a value/
 pub fun contains(text: Text, phrase: Text): Bool {
   let result = trust $ if [[ "{text}" == *"{phrase}"* ]]; then

src/tests/validity/len.ab

@@ -0,0 +1,22 @@
+// Output
+// Text literal: 5
+// Array literal: 3
+// Text variable: 6
+// Array variable: 4
+// Text reference: 6
+// Array reference: 4
+
+let name = "Andrew"
+let fruits = ["apple", "banana", "cherry", "date"]
+
+fun foo(ref text, ref arr) {
+  echo "Text reference: {len text}"
+  echo "Array reference: {len arr}"
+}
+
+echo "Text literal: {len "Hello"}"
+echo "Array literal: {len [1, 2, 3]}"
+echo "Text variable: {len name}"
+echo "Array variable: {len fruits}"
+
+foo(name, fruits)