ADDRESS, XMATCH, PROPER, REPLACE

base/src/expressions/parser/static_analysis.rs

@@ -512,6 +512,15 @@ fn args_signature_xlookup(arg_count: usize) -> Vec<Signature> {
     result
 }
 
+fn args_signature_xmatch(arg_count: usize) -> Vec<Signature> {
+    if !(2..=4).contains(&arg_count) {
+        return vec![Signature::Error; arg_count];
+    }
+    let mut result = vec![Signature::Scalar; arg_count];
+    result[1] = Signature::Vector; // lookup_array should be Vector
+    result
+}
+
 fn args_signature_textafter(arg_count: usize) -> Vec<Signature> {
     if !(2..=6).contains(&arg_count) {
         vec![Signature::Scalar; arg_count]
@@ -682,13 +691,15 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Hlookup => args_signature_hlookup(arg_count),
         Function::Index => args_signature_index(arg_count),
         Function::Indirect => args_signature_scalars(arg_count, 1, 0),
+        Function::Address => args_signature_scalars(arg_count, 2, 3),
         Function::Lookup => args_signature_lookup(arg_count),
         Function::Match => args_signature_match(arg_count),
         Function::Offset => args_signature_offset(arg_count),
         Function::Row => args_signature_row(arg_count),
         Function::Rows => args_signature_one_vector(arg_count),
         Function::Vlookup => args_signature_hlookup(arg_count),
         Function::Xlookup => args_signature_xlookup(arg_count),
+        Function::Xmatch => args_signature_xmatch(arg_count),
         Function::Concat => vec![Signature::Vector; arg_count],
         Function::Concatenate => vec![Signature::Scalar; arg_count],
         Function::Exact => args_signature_scalars(arg_count, 2, 0),
@@ -697,6 +708,8 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
         Function::Len => args_signature_scalars(arg_count, 1, 0),
         Function::Lower => args_signature_scalars(arg_count, 1, 0),
         Function::Mid => args_signature_scalars(arg_count, 3, 0),
+        Function::Proper => args_signature_scalars(arg_count, 1, 0),
+        Function::Replace => args_signature_scalars(arg_count, 4, 0),
         Function::Rept => args_signature_scalars(arg_count, 2, 0),
         Function::Right => args_signature_scalars(arg_count, 2, 1),
         Function::Search => args_signature_scalars(arg_count, 2, 1),
@@ -1076,13 +1089,15 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Hlookup => not_implemented(args),
         Function::Index => static_analysis_index(args),
         Function::Indirect => static_analysis_indirect(args),
+        Function::Address => scalar_arguments(args),
         Function::Lookup => not_implemented(args),
         Function::Match => not_implemented(args),
         Function::Offset => static_analysis_offset(args),
         Function::Row => StaticResult::Scalar,
         Function::Rows => not_implemented(args),
         Function::Vlookup => not_implemented(args),
         Function::Xlookup => not_implemented(args),
+        Function::Xmatch => scalar_arguments(args),
         Function::Concat => not_implemented(args),
         Function::Concatenate => not_implemented(args),
         Function::Exact => not_implemented(args),
@@ -1091,6 +1106,8 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
         Function::Len => not_implemented(args),
         Function::Lower => not_implemented(args),
         Function::Mid => not_implemented(args),
+        Function::Proper => scalar_arguments(args),
+        Function::Replace => scalar_arguments(args),
         Function::Rept => not_implemented(args),
         Function::Right => not_implemented(args),
         Function::Search => not_implemented(args),

base/src/formatter/format.rs

@@ -928,6 +928,11 @@ fn parse_number(
     } else {
         1.0
     };
+
+    if bytes[position] == group_separator {
+        return Err("Cannot parse number".to_string());
+    }
+
     // numbers before the decimal point
     while position < len {
         let x = bytes[position];