Regex.Compile using Truffle Regex, update find, match and match_all

CHANGELOG.md

@@ -330,6 +330,7 @@
   and renamed them to `match`, `find`, `find_all` (respectively).][5721]
 - [Updated `rename_columns` to new API. Added `first_row`, `second_row` and
   `last_row` to Table types][5719]
+- [Remove many regex compile flags; separated `match` into `match` and `match_all`.][5785]
 
 [debug-shortcuts]:
   https://github.com/enso-org/enso/blob/develop/app/gui/docs/product/shortcuts.md#debug
@@ -508,6 +509,7 @@
 [5779]: https://github.com/enso-org/enso/pull/5779
 [5757]: https://github.com/enso-org/enso/pull/5757
 [5802]: https://github.com/enso-org/enso/pull/5802
+[5785]: https://github.com/enso-org/enso/pull/5785
 
 #### Enso Compiler
 

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text/Extensions.enso

@@ -12,18 +12,18 @@ import project.Data.Text.Case_Sensitivity.Case_Sensitivity
 import project.Data.Text.Encoding.Encoding
 import project.Data.Text.Location
 import project.Data.Text.Matching_Mode.Matching_Mode
-import project.Data.Text.Regex
 import project.Data.Text.Regex.Match.Match
 import project.Data.Text.Regex.Regex_Mode.Regex_Mode
 import project.Data.Text.Regex_Matcher.Regex_Matcher
+import project.Data.Text.Regex_2
+import project.Data.Text.Regex_2.Regex_Syntax_Error
 import project.Data.Text.Span.Span
 import project.Data.Text.Span.Utf_16_Span
 import project.Data.Text.Text
 import project.Data.Text.Text_Matcher.Text_Matcher
 import project.Data.Text.Text_Sub_Range.Codepoint_Ranges
 import project.Data.Text.Text_Sub_Range.Text_Sub_Range
 import project.Data.Vector.Vector
-import project.Error.Common.Compile_Error
 import project.Error.Common.Index_Out_Of_Bounds
 import project.Error.Error
 import project.Error.Encoding_Error.Encoding_Error
@@ -227,10 +227,10 @@ Text.characters self =
          example_find_insensitive =
              ## This matches `aBc` @ character 11
              "aabbbbccccaaBcaaaa".find "a[ab]c" Case_Sensitivity.Insensitive
-Text.find : Text -> Case_Sensitivity -> Match | Nothing ! Compile_Error
+Text.find : Text -> Case_Sensitivity -> Match | Nothing ! Regex_Syntax_Error
 Text.find self pattern=".*" case_sensitivity=Case_Sensitivity.Sensitive =
     case_insensitive = case_sensitivity.is_case_insensitive_in_memory
-    Regex.compile pattern case_insensitive=case_insensitive . match self Matching_Mode.First
+    Regex_2.compile pattern case_insensitive=case_insensitive . match self
 
 ## Finds all the matches of the regular expression `pattern` in `self`,
    returning a Vector. If not found, will be an empty Vector.
@@ -249,12 +249,10 @@ Text.find self pattern=".*" case_sensitivity=Case_Sensitivity.Sensitive =
          example_find_all_insensitive =
               ## This matches `aABbbbc` @ character 0 and `aBC` @ character 11
              "aABbbbccccaaBCaaaa".find_all "a[ab]+c" Case_Sensitivity.Insensitive
-Text.find_all : Text -> Case_Sensitivity -> Vector Match ! Compile_Error
+Text.find_all : Text -> Case_Sensitivity -> Vector Match ! Regex_Syntax_Error
 Text.find_all self pattern=".*" case_sensitivity=Case_Sensitivity.Sensitive =
     case_insensitive = case_sensitivity.is_case_insensitive_in_memory
-    case Regex.compile pattern case_insensitive=case_insensitive . match self Regex_Mode.All of
-        Nothing -> []
-        matches -> matches
+    Regex_2.compile pattern case_insensitive=case_insensitive . match_all self
 
 ## ALIAS Check Matches
 
@@ -276,10 +274,10 @@ Text.find_all self pattern=".*" case_sensitivity=Case_Sensitivity.Sensitive =
              regex = ".+ct@.+"
              # Evaluates to true
              "[email protected]".match regex Case_Sensitivity.Insensitive
-Text.match : Text -> Case_Sensitivity -> Boolean ! Compile_Error
+Text.match : Text -> Case_Sensitivity -> Boolean ! Regex_Syntax_Error
 Text.match self pattern=".*" case_sensitivity=Case_Sensitivity.Sensitive =
     case_insensitive = case_sensitivity.is_case_insensitive_in_memory
-    compiled_pattern = Regex.compile pattern case_insensitive=case_insensitive
+    compiled_pattern = Regex_2.compile pattern case_insensitive=case_insensitive
     compiled_pattern.matches self
 
 ## ALIAS Split Text

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text/Prim_Text_Helper.enso

@@ -1,9 +1,24 @@
 ## Internal text utilities for inspecting text primitives.
 
+import project.Any.Any
 import project.Data.Text.Text
 
 ## PRIVATE
 
    Forces flattening of a text value.
 optimize : Text
 optimize text = @Builtin_Method "Prim_Text_Helper.optimize"
+
+## PRIVATE
+
+   Compile the regex using the Truffle regex library.
+
+   Returns a Java RegexObject (Truffle)
+   (See https://github.com/oracle/graal/blob/master/regex/docs/README.md)
+
+   Arguments:
+   - pattern: the regex to compile
+   - options: string containing traditional regex flags (for example, "g"
+    as in "/foo/g"
+compile_regex : Text -> Text -> Any
+compile_regex pattern options = @Builtin_Method "Prim_Text_Helper.compile_regex"

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text/Regex/Match_2.enso

@@ -0,0 +1,67 @@
+from project.Data.Boolean import Boolean, True, False
+import project.Data.Numbers.Integer
+import project.Data.Range.Range
+import project.Data.Text.Span.Span
+import project.Data.Text.Span.Utf_16_Span
+import project.Data.Text.Text
+import project.Nothing.Nothing
+
+type Match_2
+    ## internal_regex_result : RegexResult (Truffle)
+       (See https://github.com/oracle/graal/blob/master/regex/docs/README.md)
+    Value (pattern : Pattern_2) (internal_regex_result : Any) (input : Text)
+
+    ## PRIVATE
+       Returns the start character of group n.
+
+       Arguments:
+       - n: the integer group number. Note that the groups explicitly
+         defined in the regex are numbered starting at 1; group 0 refers to the
+         entire match range.
+    start : Integer -> Integer
+    start self n = self.internal_regex_result.getStart n
+
+    ## PRIVATE
+       Returns the start character of group n
+
+       Arguments:
+       - n: the integer group number
+    end : Integer -> Integer
+    end self n = self.internal_regex_result.getEnd n
+
+    ## PRIVATE
+
+       Gets the text matched by the group with the provided identifier, or
+       `Nothing` if the group did not participate in the match. If no such group
+       exists for the provided identifier, a `No_Such_Group` is returned.
+
+       Arguments:
+       - id: The integer index or name of that group.
+
+       ? The Full Match
+         The group with index 0 is always the full match of the pattern.
+
+       ? Named Groups by Index
+         If the regex contained named groups, these may also be accessed by
+         index based on their position in the pattern.
+
+       Note that it is possible for a group to "not participate in the match",
+       for example with a disjunction. In the example below, the "(d)" group
+       does not participate -- it neither matches nor fails.
+
+            "ab((c)|(d))".find "abc"
+
+       In this case, the group id for "(d)", which is 3, is a valid group id and
+       (Pattern_2.lookup_group 3) will return 3. If the caller tries to get group 3,
+       Match_2.group will return Nothing.
+    group : Integer | Text -> Span
+    group self id =
+        n = self.pattern.lookup_group id
+        start = self.start n
+        end = self.end n
+        does_not_participate = start == -1 || end == -1
+        case does_not_participate of
+            True -> Nothing
+            False ->
+                range = Range.new (self.start n) (self.end n)
+                (Utf_16_Span.Value range self.input).to_grapheme_span

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Text/Regex/Pattern_2.enso

@@ -0,0 +1,177 @@
+import project.Any.Any
+#import project.Data.Boolean.Boolean
+from project.Data.Boolean import Boolean, True, False
+import project.Data.Map.Map
+import project.Data.Numbers.Integer
+import project.Data.Range.Extensions
+import project.Data.Range.Range
+import project.Data.Text.Span.Span
+import project.Data.Text.Span.Utf_16_Span
+import project.Data.Text.Regex.Match_2.Match_2
+import project.Data.Text.Regex_2.No_Such_Group
+import project.Data.Text.Text
+import project.Data.Vector.Vector
+import project.Error.Error
+import project.Meta
+import project.Nothing.Nothing
+import project.Panic.Panic
+import project.Polyglot
+
+polyglot java import org.enso.base.Text_Utils
+
+type Pattern_2
+    ## internal_regex_object : RegexObject (Truffle)
+       (See https://github.com/oracle/graal/blob/master/regex/docs/README.md)
+    Value (internal_regex_object : Any)
+
+    ## Returns `True` if the input matches against the pattern described by
+       `self`, otherwise `False`.
+
+       Arguments:
+       - input: The text to check for matching.
+    matches : Text -> Boolean
+    matches self input =
+        m = self.internal_regex_object.exec input 0
+        m . isMatch && m.getStart 0 == 0 && m.getEnd 0 == input.length
+
+    ## Tries to match the provided `input` against the pattern `self`.
+
+       Arguments:
+       - input: The text to match the pattern described by `self` against.
+    match : Text -> Match_2 | Nothing
+    match self input =
+        it = Match_Iterator.new self input
+        case it.next of
+            Match_Iterator_Value.Next _ match _ -> match
+            Match_Iterator_Value.Last _ -> Nothing
+
+    ## Tries to match the provided `input` against the pattern `self`.
+
+       Returns a Vector of Match_2 objects.
+
+       Arguments:
+       - input: The text to match the pattern described by `self` against.
+    match_all : Text -> Vector Match_2
+    match_all self input =
+        builder = Vector.new_builder
+        it = Match_Iterator.new self input
+        go it = case it.next of
+            Match_Iterator_Value.Next _ match next_it ->
+                builder.append match
+                go next_it
+            Match_Iterator_Value.Last _ -> Nothing
+        go it
+        builder.to_vector
+
+    ## PRIVATE
+
+       Look up a match group name or number, and check that it is valid.
+
+       Arguments:
+       - id: The name or number of the group that was asked for.
+
+       Returns: a group number.
+
+       A group number is invalid if it is outside the range of groups
+       that were in the original pattern.
+
+       A group name is invalid if it was not defined in the original pattern.
+
+       A group name is an alias for a group number; if a name is passed to
+       this method, it returns the corresponding group number.
+
+       Note that it is possible for a group to "not participate in the match",
+       for example with a disjunction. In the example below, the "(d)" group
+       does not participate -- it neither matches nor fails.
+
+            "ab((c)|(d))".find "abc"
+
+       In this case, the group id for "(d)", which is 3, is a valid group id and
+       (Pattern_2.lookup_group 3) will return 3. If the caller tries to get group 3,
+       Match_2.group will return Nothing.
+
+    lookup_group : Integer | Text -> Integer ! No_Such_Group
+    lookup_group self id =
+        case id of
+            n : Integer -> case (n >= 0 && n < self.internal_regex_object.groupCount) of
+                True -> n
+                False -> Error.throw (No_Such_Group.Error n)
+            name : Text ->
+                # Maps name to number
+                groups = self.internal_regex_object.groups
+
+                n = case groups of
+                        # If Nothing, there are no named groups
+                        Nothing -> Error.throw (No_Such_Group.Error name)
+                        _ ->
+                            qq = (read_group_map groups name)
+                            case qq of
+                                Nothing -> Nothing
+                                n : Integer -> n
+                case n of
+                    _ : Integer -> n
+                    Nothing -> Error.throw (No_Such_Group.Error name)
+
+## PRIVATE
+
+    Performs the regex match, and iterates through the results. Yields both
+    the matched parts of the string, and the 'filler' parts between them.
+
+    At each step, it yields a Match_Iterator_Value, whivch has either a filler
+    and a match, or just the final filler. A Match_Iterator_Value.Last value is
+    return at the end, and only at the end.
+type Match_Iterator
+    new : Pattern_2 -> Text -> Match_Iterator
+    new pattern input = Match_Iterator.Value pattern input 0
+
+    Value (pattern : Pattern_2) (input : Text) (cursor : Integer)
+
+    next : Match_Iterator_Value
+    next self =
+        regex_result = self.pattern.internal_regex_object.exec self.input self.cursor
+        case regex_result.isMatch of
+            False ->
+                filler_range = Range.new self.cursor (Text_Utils.char_length self.input)
+                filler_span = (Utf_16_Span.Value filler_range self.input).to_grapheme_span
+                Match_Iterator_Value.Last filler_span
+            True ->
+                match_start = regex_result.getStart 0
+                filler_range = Range.new self.cursor match_start
+                filler_span = (Utf_16_Span.Value filler_range self.input).to_grapheme_span
+                match = Match_2.Value self.pattern regex_result self.input
+                next_cursor = match.end 0
+                next_iterator = Match_Iterator.Value self.pattern self.input next_cursor
+                Match_Iterator_Value.Next filler_span match next_iterator
+
+    to_text_debug : Vector Text
+    to_text_debug self =
+        vb = Vector.new_builder
+        go it = case it.next of
+            Match_Iterator_Value.Next filler match next_it ->
+                vb.append ('\"' + filler.text + '\"')
+                vb.append ("/" + (match.span 0).text + "/")
+                go next_it
+            Match_Iterator_Value.Last filler ->
+                vb.append ('\"' + filler.text + '\"')
+        go self
+        vb.to_vector
+
+## PRIVATE
+type Match_Iterator_Value
+  Next (filler : Span) (match : Match_2) (next_iterator : Match_Iterator)
+  Last (filler : Span)
+
+## PRIVATE
+group_map_contains : Any -> Text -> Boolean
+group_map_contains map elem =
+    members = Polyglot.get_members map
+    as_vec = Vector.from_polyglot_array members
+    as_vec.contains elem
+
+## PRIVATE
+read_group_map : Any -> Text -> Integer | Nothing
+read_group_map map name =
+    case group_map_contains map name of
+        True -> Polyglot.get_member map name
+        False -> Nothing
+