Markdown stuff

Author: expenses

internal/compiler/builtin_macros.rs

@@ -87,7 +87,6 @@ pub fn lower_macro(
         }
         BuiltinMacroFunction::Rgb => rgb_macro(n, sub_expr.collect(), diag),
         BuiltinMacroFunction::Hsv => hsv_macro(n, sub_expr.collect(), diag),
-        BuiltinMacroFunction::Markdown => markdown_macro(n, sub_expr.collect()),
     }
 }
 
@@ -318,30 +317,6 @@ fn debug_macro(
     }
 }
 
-fn markdown_macro(node: &dyn Spanned, args: Vec<(Expression, Option<NodeOrToken>)>) -> Expression {
-    let mut string = None;
-    for (expr, node) in args {
-        let escaped = Expression::FunctionCall {
-            function: BuiltinFunction::EscapeMarkdown.into(),
-            arguments: vec![expr],
-            source_location: Some(node.to_source_location()),
-        };
-        string = Some(match string {
-            None => escaped,
-            Some(string) => Expression::BinaryExpression {
-                lhs: Box::new(string),
-                op: '+',
-                rhs: Box::new(escaped),
-            },
-        });
-    }
-    Expression::FunctionCall {
-        function: BuiltinFunction::ParseMarkdown.into(),
-        arguments: vec![string.unwrap_or_else(|| Expression::default_value_for_type(&Type::String))],
-        source_location: Some(node.to_source_location()),
-    }
-}
-
 fn to_debug_string(
     expr: Expression,
     node: &dyn Spanned,

internal/compiler/expression_tree.rs

@@ -142,8 +142,6 @@ pub enum BuiltinMacroFunction {
     Hsv,
     /// transform `debug(a, b, c)` into debug `a + " " + b + " " + c`
     Debug,
-    /// Markdown
-    Markdown,
 }
 
 macro_rules! declare_builtin_function_types {
@@ -283,7 +281,7 @@ declare_builtin_function_types!(
     RestartTimer: (Type::ElementReference) -> Type::Void,
     OpenUrl: (Type::String) -> Type::Void,
     EscapeMarkdown: (Type::String) -> Type::String,
-    ParseMarkdown: (Type::String) -> Type::Void
+    ParseMarkdown: (Type::String) -> Type::String
 );
 
 impl BuiltinFunction {

internal/compiler/generator/cpp.rs

@@ -4109,6 +4109,14 @@ fn compile_builtin_function_call(
             let url = a.next().unwrap();
             format!("slint::cbindgen_private::open_url({})", url)
         }
+        BuiltinFunction::EscapeMarkdown => {
+            let text = a.next().unwrap();
+            format!("slint::cbindgen_private::escape_markdown({})", text)
+        }
+        BuiltinFunction::ParseMarkdown => {
+            let text = a.next().unwrap();
+            format!("slint::cbindgen_private::parse_markdown({})", text)
+        }
     }
 }
 

internal/compiler/generator/rust.rs

@@ -3375,6 +3375,14 @@ fn compile_builtin_function_call(
             let url = a.next().unwrap();
             quote!(sp::open_url(&#url))
         }
+        BuiltinFunction::EscapeMarkdown => {
+            let text = a.next().unwrap();
+            quote!(sp::escape_markdown(&#text))
+        }
+        BuiltinFunction::ParseMarkdown => {
+            let text = a.next().unwrap();
+            quote!(sp::parse_markdown(&#text))
+        }
     }
 }
 

internal/compiler/parser.rs

@@ -383,6 +383,7 @@ declare_syntax! {
         AtGradient -> [*Expression],
         /// `@tr("foo", ...)`  // the string is a StringLiteral
         AtTr -> [?TrContext, ?TrPlural, *Expression],
+        AtMarkdown -> [*Expression],
         /// `"foo" =>`  in a `AtTr` node
         TrContext -> [],
         /// `| "foo" % n`  in a `AtTr` node

internal/compiler/parser/expressions.rs

@@ -252,6 +252,9 @@ fn parse_at_keyword(p: &mut impl Parser) {
         "tr" => {
             parse_tr(p);
         }
+        "markdown" => {
+            parse_markdown(p);
+        },
         _ => {
             p.consume();
             p.test(SyntaxKind::Identifier); // consume the identifier, so that autocomplete works
@@ -435,6 +438,37 @@ fn parse_tr(p: &mut impl Parser) {
     p.expect(SyntaxKind::RParent);
 }
 
+fn parse_markdown(p: &mut impl Parser) {
+    let mut p = p.start_node(SyntaxKind::AtMarkdown);
+    p.expect(SyntaxKind::At);
+    debug_assert!(p.peek().as_str().ends_with("markdown"));
+    p.expect(SyntaxKind::Identifier); //eg "markdown"
+    p.expect(SyntaxKind::LParent);
+    
+    fn consume_literal(p: &mut impl Parser) -> bool {
+        let peek = p.peek();
+        if peek.kind() != SyntaxKind::StringLiteral
+            || !peek.as_str().starts_with('"')
+            || !peek.as_str().ends_with('"')
+        {
+            p.error("Expected plain string literal");
+            return false;
+        }
+        p.expect(SyntaxKind::StringLiteral)
+    }
+
+    if !consume_literal(&mut *p) {
+        return;
+    }
+
+    while p.test(SyntaxKind::Comma) {
+        if !parse_expression(&mut *p) {
+            break;
+        }
+    }
+    p.expect(SyntaxKind::RParent);
+}
+
 #[cfg_attr(test, parser_test)]
 /// ```test,AtImageUrl
 /// @image-url("foo.png")

internal/compiler/passes/resolving.rs

@@ -356,6 +356,7 @@ impl Expression {
                     SyntaxKind::AtImageUrl => Some(Self::from_at_image_url_node(node.into(), ctx)),
                     SyntaxKind::AtGradient => Some(Self::from_at_gradient(node.into(), ctx)),
                     SyntaxKind::AtTr => Some(Self::from_at_tr(node.into(), ctx)),
+                    SyntaxKind::AtMarkdown => Some(Self::from_at_markdown(node.into(), ctx)),
                     SyntaxKind::QualifiedName => Some(Self::from_qualified_name_node(
                         node.clone().into(),
                         ctx,
@@ -703,6 +704,126 @@ impl Expression {
             }
         }
     }
+    
+    fn from_at_markdown(node: syntax_nodes::AtMarkdown, ctx: &mut LookupCtx) -> Expression {
+        let Some(string) = std::dbg!(node
+            .child_text(SyntaxKind::StringLiteral))
+            .and_then(|s| crate::literals::unescape_string(&s))
+        else {
+            ctx.diag.push_error("Cannot parse string literal".into(), &node);
+            return Expression::Invalid;
+        };
+        
+        let subs = node.Expression().map(|n| {
+            Expression::from_expression_node(n.clone(), ctx).maybe_convert_to(
+                Type::String,
+                &n,
+                ctx.diag,
+            )
+        });
+        let values = subs.collect::<Vec<_>>();
+        std::dbg!(&values);
+
+        let mut expr = None;
+        
+        // check format string
+        {
+            let mut arg_idx = 0;
+            let mut pos_max = 0;
+            let mut pos = 0;
+            let mut literal_start_pos = 0;
+            while let Some(mut p) = string[pos..].find(['{', '}']) {
+                if string.len() - pos < p + 1 {
+                    ctx.diag.push_error(
+                        "Unescaped trailing '{' in format string. Escape '{' with '{{'".into(),
+                        &node,
+                    );
+                    break;
+                }
+                p += pos;
+
+                // Skip escaped }
+                if string.get(p..=p) == Some("}") {
+                    if string.get(p + 1..=p + 1) == Some("}") {
+                        pos = p + 2;
+                        continue;
+                    } else {
+                        ctx.diag.push_error(
+                            "Unescaped '}' in format string. Escape '}' with '}}'".into(),
+                            &node,
+                        );
+                        break;
+                    }
+                }
+
+                // Skip escaped {
+                if string.get(p + 1..=p + 1) == Some("{") {
+                    pos = p + 2;
+                    continue;
+                }
+
+                // Find the argument
+                let end = if let Some(end) = string[p..].find('}') {
+                    end + p
+                } else {
+                    ctx.diag.push_error(
+                        "Unterminated placeholder in format string. '{' must be escaped with '{{'"
+                            .into(),
+                        &node,
+                    );
+                    break;
+                };
+                let argument = &string[p + 1..end];
+                if argument.is_empty() {
+                    arg_idx += 1;
+                } else if let Ok(n) = argument.parse::<u16>() {
+                    pos_max = pos_max.max(n as usize + 1);
+                } else {
+                    ctx.diag
+                        .push_error("Invalid '{...}' placeholder in format string. The placeholder must be a number, or braces must be escaped with '{{' and '}}'".into(), &node);
+                    break;
+                };
+                let add = Expression::BinaryExpression {
+                    lhs: Box::new(Expression::StringLiteral((&string[literal_start_pos..p]).into())),
+                    op: '+',
+                    rhs: Box::new(values[arg_idx-1].clone())
+                };
+                expr = Some(match expr {
+                    None => add,
+                    Some(expr) => Expression::BinaryExpression {
+                        lhs: Box::new(expr),
+                        op: '+',
+                        rhs: Box::new(add),
+                    },
+                });
+                pos = end + 1;
+                literal_start_pos = pos;
+            }
+            if arg_idx > 0 && pos_max > 0 {
+                ctx.diag.push_error(
+                    "Cannot mix positional and non-positional placeholder in format string".into(),
+                    &node,
+                );
+            } else if arg_idx > values.len() || pos_max > values.len() {
+                let num = arg_idx.max(pos_max);
+                ctx.diag.push_error(
+                    format!("Format string contains {num} placeholders, but only {} extra arguments were given", values.len()),
+                    &node,
+                );
+            }            
+        }
+        
+        std::dbg!(&expr);
+
+        Expression::FunctionCall {
+            function: BuiltinFunction::ParseMarkdown.into(),
+            arguments: vec![
+                expr.unwrap()//Expression::StringLiteral(string),
+                
+            ],
+            source_location: Some(node.to_source_location()),
+        }
+    }
 
     fn from_at_tr(node: syntax_nodes::AtTr, ctx: &mut LookupCtx) -> Expression {
         let Some(string) = node

internal/core/lib.rs

@@ -172,3 +172,13 @@ pub fn open_url(url: &str) {
         debug_log!("Error opening url {}: {}", url, err);
     }
 }
+
+pub fn escape_markdown(text: &str) -> std::string::String  {
+    std::dbg!(text);
+    text.into()
+}
+
+pub fn parse_markdown(text: &str) -> std::string::String {
+    std::dbg!(text);
+    text.into()
+}

internal/interpreter/eval.rs

@@ -1396,6 +1396,16 @@ fn call_builtin_function(
             corelib::open_url(&url);
             Value::Void
         }
+        BuiltinFunction::EscapeMarkdown => {
+            let text: SharedString =
+                eval_expression(&arguments[0], local_context).try_into().unwrap();
+             Value::String(corelib::escape_markdown(&text).into())
+        }
+        BuiltinFunction::ParseMarkdown => {
+            let text: SharedString =
+                eval_expression(&arguments[0], local_context).try_into().unwrap();
+             Value::String(corelib::parse_markdown(&text).into())
+        }
     }
 }