Add Str.contains built-in (#8436)

Author: niclas-ahden

src/build/builtin_compiler/main.zig

@@ -101,6 +101,9 @@ fn replaceStrIsEmptyWithLowLevel(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
     if (env.common.findIdent("Builtin.Str.concat")) |str_concat_ident| {
         try low_level_map.put(str_concat_ident, .str_concat);
     }
+    if (env.common.findIdent("Builtin.Str.contains")) |str_contains_ident| {
+        try low_level_map.put(str_contains_ident, .str_contains);
+    }
     if (env.common.findIdent("Builtin.Str.trim")) |str_trim_ident| {
         try low_level_map.put(str_trim_ident, .str_trim);
     }

src/build/roc/Builtin.roc

@@ -2,13 +2,11 @@ Builtin :: [].{
 	Str :: [ProvidedByCompiler].{
 		is_empty : Str -> Bool
 		concat : Str, Str -> Str
+		contains : Str, Str -> Bool
 		trim : Str -> Str
 		caseless_ascii_equals : Str, Str -> Bool
 		with_ascii_lowercased : Str -> Str
 		with_ascii_uppercased : Str -> Str
-
-		contains : Str, Str -> Bool
-		contains = |_str, _other| True
 	}
 
 	List(_item) :: [ProvidedByCompiler].{

src/builtins/str.zig

@@ -801,6 +801,11 @@ pub fn strConcat(
     }
 }
 
+/// Str.contains
+pub fn strContains(haystack: RocStr, needle: RocStr) callconv(.c) bool {
+    return std.mem.indexOf(u8, haystack.asSlice(), needle.asSlice()) != null;
+}
+
 /// TODO: Document RocListStr.
 pub const RocListStr = extern struct {
     list_elements: ?[*]RocStr,

src/canonicalize/Expression.zig

@@ -402,6 +402,7 @@ pub const Expr = union(enum) {
         // String operations
         str_is_empty,
         str_concat,
+        str_contains,
         str_trim,
         str_caseless_ascii_equals,
         str_with_ascii_lowercased,

src/eval/interpreter.zig

@@ -2801,6 +2801,23 @@ pub const Interpreter = struct {
                 out.is_initialized = true;
                 return out;
             },
+            .str_contains => {
+                // Str.contains : Str, Str -> Bool
+                std.debug.assert(args.len == 2);
+
+                const haystack_arg = args[0];
+                const needle_arg = args[1];
+
+                std.debug.assert(haystack_arg.ptr != null);
+                std.debug.assert(needle_arg.ptr != null);
+
+                const haystack: *const RocStr = @ptrCast(@alignCast(haystack_arg.ptr.?));
+                const needle: *const RocStr = @ptrCast(@alignCast(needle_arg.ptr.?));
+
+                const result = builtins.str.strContains(haystack.*, needle.*);
+
+                return try self.makeBoolValue(result);
+            },
             .str_trim => {
                 // Str.trim : Str -> Str
                 std.debug.assert(args.len == 1);

src/eval/test/low_level_interp_test.zig

@@ -276,6 +276,69 @@ test "e_low_level_lambda - Str.concat with longer strings" {
     try testing.expectEqualStrings("\"This is a longer string that contains about one hundred characters for testing concatenation. This is the second string that also has many characters in it for testing longer string operations.\"", value);
 }
 
+test "e_low_level_lambda - Str.contains with substring in middle" {
+    const src =
+        \\x = Str.contains("foobarbaz", "bar")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("True", value);
+}
+
+test "e_low_level_lambda - Str.contains with non-matching strings" {
+    const src =
+        \\x = Str.contains("apple", "orange")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("False", value);
+}
+
+test "e_low_level_lambda - Str.contains with empty needle" {
+    const src =
+        \\x = Str.contains("anything", "")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("True", value);
+}
+
+test "e_low_level_lambda - Str.contains with substring at start" {
+    const src =
+        \\x = Str.contains("hello world", "hello")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("True", value);
+}
+
+test "e_low_level_lambda - Str.contains with substring at end" {
+    const src =
+        \\x = Str.contains("hello world", "world")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("True", value);
+}
+
+test "e_low_level_lambda - Str.contains with empty haystack" {
+    const src =
+        \\x = Str.contains("", "hello")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("False", value);
+}
+
+test "e_low_level_lambda - Str.contains with identical strings" {
+    const src =
+        \\x = Str.contains("test", "test")
+    ;
+    const value = try evalModuleAndGetString(src, 0, test_allocator);
+    defer test_allocator.free(value);
+    try testing.expectEqualStrings("True", value);
+}
+
 test "e_low_level_lambda - Str.caseless_ascii_equals with equal strings" {
     const src =
         \\x = Str.caseless_ascii_equals("hello", "hello")

test/snapshots/repl/str_contains.md

@@ -0,0 +1,31 @@
+# META
+~~~ini
+description=Str.contains should work with various string combinations
+type=repl
+~~~
+# SOURCE
+~~~roc
+» Str.contains("foobarbaz", "bar")
+» Str.contains("apple", "orange")
+» Str.contains("anything", "")
+» Str.contains("hello world", "hello")
+» Str.contains("hello world", "world")
+» Str.contains("test", "test")
+» Str.contains("", "hello")
+~~~
+# OUTPUT
+True
+---
+False
+---
+True
+---
+True
+---
+True
+---
+True
+---
+False
+# PROBLEMS
+NIL