mt-lang 0.4.23 → 0.4.25

data/std/toml.mt

@@ -634,7 +634,8 @@ function parse_string(parser: ref[Parser]) -> Result[string.String, ParseError]:
     if not parser_consume_byte(parser, byte_quote):
         return Result[string.String, ParseError].failure(error= parse_error(parser, "expected string"))
 
-    var result = string.String.create()
+    # Moved into the success result on every exit path.
+    var result = string.String.create()  # lint: ignore(owning-release-leak)
     while true:
         match parser_peek_byte(parser):
             Option.none:
@@ -801,8 +802,7 @@ function parse_array(parser: ref[Parser]) -> Result[ptr[Array]?, ParseError]:
         return Result[ptr[Array]?, ParseError].failure(error= parse_error(parser, "expected array"))
 
     let array_ptr = heap.must_alloc[Array](1)
-    unsafe:
-        read(array_ptr) = Array.create()
+    read(array_ptr) = Array.create()
 
     parser_skip_inline_space(parser)
     if parser_consume_byte(parser, byte_right_bracket):
@@ -813,13 +813,11 @@ function parse_array(parser: ref[Parser]) -> Result[ptr[Array]?, ParseError]:
         let value_result = parse_value(parser)
         match value_result:
             Result.failure as payload:
-                unsafe:
-                    read(array_ptr).release()
+                read(array_ptr).release()
                 heap.release(array_ptr)
                 return Result[ptr[Array]?, ParseError].failure(error= payload.error)
             Result.success as payload:
-                unsafe:
-                    read(array_ptr).values.push(payload.value)
+                read(array_ptr).values.push(payload.value)
 
         parser_skip_inline_space(parser)
         if parser_consume_byte(parser, byte_comma):
@@ -827,8 +825,7 @@ function parse_array(parser: ref[Parser]) -> Result[ptr[Array]?, ParseError]:
         if parser_consume_byte(parser, byte_right_bracket):
             return Result[ptr[Array]?, ParseError].success(value= array_ptr)
 
-        unsafe:
-            read(array_ptr).release()
+        read(array_ptr).release()
         heap.release(array_ptr)
         return Result[ptr[Array]?, ParseError].failure(error= parse_error(parser, "expected ',' or ']'"))
 
@@ -838,8 +835,7 @@ function parse_inline_object(parser: ref[Parser]) -> Result[ptr[Object]?, ParseE
         return Result[ptr[Object]?, ParseError].failure(error= parse_error(parser, "expected inline table"))
 
     let object_ptr = heap.must_alloc[Object](1)
-    unsafe:
-        read(object_ptr) = Object.create()
+    read(object_ptr) = Object.create()
 
     parser_skip_inline_space(parser)
     if parser_consume_byte(parser, byte_right_brace):
@@ -850,8 +846,7 @@ function parse_inline_object(parser: ref[Parser]) -> Result[ptr[Object]?, ParseE
         let key_result = parse_key(parser)
         match key_result:
             Result.failure as payload:
-                unsafe:
-                    read(object_ptr).release()
+                read(object_ptr).release()
                 heap.release(object_ptr)
                 return Result[ptr[Object]?, ParseError].failure(error= payload.error)
             Result.success as key_payload:
@@ -859,8 +854,7 @@ function parse_inline_object(parser: ref[Parser]) -> Result[ptr[Object]?, ParseE
                 parser_skip_inline_space(parser)
                 if not parser_consume_byte(parser, byte_equal):
                     key.release()
-                    unsafe:
-                        read(object_ptr).release()
+                    read(object_ptr).release()
                     heap.release(object_ptr)
                     return Result[ptr[Object]?, ParseError].failure(error= parse_error(parser, "expected '='"))
 
@@ -869,22 +863,19 @@ function parse_inline_object(parser: ref[Parser]) -> Result[ptr[Object]?, ParseE
                 match value_result:
                     Result.failure as payload:
                         key.release()
-                        unsafe:
-                            read(object_ptr).release()
+                        read(object_ptr).release()
                         heap.release(object_ptr)
                         return Result[ptr[Object]?, ParseError].failure(error= payload.error)
                     Result.success as value_payload:
                         let key_text = key.as_str()
-                        if unsafe: read(object_ptr).contains(key_text):
+                        if read(object_ptr).contains(key_text):
                             key.release()
                             release_value(value_payload.value)
-                            unsafe:
-                                read(object_ptr).release()
+                            read(object_ptr).release()
                             heap.release(object_ptr)
                             return Result[ptr[Object]?, ParseError].failure(error= parse_error(parser, "duplicate key"))
 
-                        unsafe:
-                            read(object_ptr).entries.push(Entry(key = key, value = value_payload.value))
+                        read(object_ptr).entries.push(Entry(key = key, value = value_payload.value))
 
                 parser_skip_inline_space(parser)
                 if parser_consume_byte(parser, byte_comma):
@@ -892,8 +883,7 @@ function parse_inline_object(parser: ref[Parser]) -> Result[ptr[Object]?, ParseE
                 if parser_consume_byte(parser, byte_right_brace):
                     return Result[ptr[Object]?, ParseError].success(value= object_ptr)
 
-                unsafe:
-                    read(object_ptr).release()
+                read(object_ptr).release()
                 heap.release(object_ptr)
                 return Result[ptr[Object]?, ParseError].failure(error= parse_error(parser, "expected ',' or '}'"))
 
@@ -948,11 +938,15 @@ function parse_value(parser: ref[Parser]) -> Result[Value, ParseError]:
 
 
 function document_find_table_index(document: ref[Document], name: str) -> Option[ptr_uint]:
-    return document.tables.find_index(proc(table_ptr: ptr[Table]) -> bool: unsafe: read(table_ptr).name.as_str().equal(name))
+    return document.tables.find_index(
+        proc(table_ptr: ptr[Table]) -> bool: unsafe: read(table_ptr).name.as_str().equal(name)
+    )
 
 
 function document_find_array_table_index(document: ref[Document], name: str) -> Option[ptr_uint]:
-    return document.array_tables.find_index(proc(table_ptr: ptr[ArrayTable]) -> bool: unsafe: read(table_ptr).name.as_str().equal(name))
+    return document.array_tables.find_index(
+        proc(table_ptr: ptr[ArrayTable]) -> bool: unsafe: read(table_ptr).name.as_str().equal(name)
+    )
 
 
 function current_object_contains(document: ref[Document], cursor: Cursor, key: str) -> bool:
@@ -1107,7 +1101,8 @@ function parse_header(document: ref[Document], cursor: ref[Cursor], parser: ref[
 
 public function parse(text_value: str) -> Result[Document, ParseError]:
     var parser = Parser(text_value = text_value, index = 0, line = 1, column = 1)
-    var document = Document.create()
+    # Moved into the success result; released on every failure return.
+    var document = Document.create()  # lint: ignore(owning-release-leak)
     var cursor = Cursor(kind = SectionKind.root, table_index = 0, array_table_index = 0, array_item_index = 0)
 
     while true:
@@ -1177,10 +1172,7 @@ function bare_header_name(text_value: str) -> bool:
 
 
 function append_header_name(output: ref[string.String], name: str) -> void:
-    if bare_header_name(name):
-        output.append(name)
-    else:
-        append_quoted_string(output, name)
+    if bare_header_name(name): output.append(name) else: append_quoted_string(output, name)
 
 
 function append_entry_key(output: ref[string.String], key: str) -> void:

data/std/uri.mt

@@ -111,7 +111,8 @@ function ascii_digit(value: ubyte) -> bool:
 
 
 function leading_slash_drive_path(path_text: str) -> bool:
-    return path_text.len >= 3 and path_text.byte_at(0) == 47 and ascii_letter(path_text.byte_at(1)) and path_text.byte_at(2) == 58
+    return path_text.len >= 3 and path_text.byte_at(0) == 47 and
+        ascii_letter(path_text.byte_at(1)) and path_text.byte_at(2) == 58
 
 
 function owned_utf8_view(value: string.String) -> Option[str]:

data/std/utility.mt

@@ -64,7 +64,7 @@ function combine_scores(mode: CombineMode, scores: ref[vec.Vec[float]]) -> float
                 return 0.0
             product = product * s
             i += 1
-        let exponent = 1.0 / float<-n
+        let exponent = 1.0 / n
         return float<-math.pow(double<-product, double<-exponent)
 
     if mode == CombineMode.multiplicative:
@@ -88,7 +88,7 @@ function combine_scores(mode: CombineMode, scores: ref[vec.Vec[float]]) -> float
                 break
             sum = sum + unsafe: read(s_ptr)
             i += 1
-        return sum / float<-n
+        return sum / n
 
     if mode == CombineMode.minimum:
         var best: float = 1.0

data/std/vec.mt

@@ -105,10 +105,7 @@ extending Vec[T]:
             new_capacity = 4
 
         while new_capacity < min_capacity:
-            if new_capacity > heap.ptr_uint_max / 2:
-                new_capacity = min_capacity
-            else:
-                new_capacity *= 2
+            if new_capacity > heap.ptr_uint_max / 2: new_capacity = min_capacity else: new_capacity *= 2
 
         let resized = heap.resize[T](this.data, new_capacity) else:
             fatal(c"vec.reserve out of memory")
@@ -348,6 +345,7 @@ extending Iter[T]:
                 total += 1
 
 
+extending Vec[T]:
     public editable function sort() -> void:
         if this.len <= 1:
             return
@@ -419,17 +417,15 @@ extending Iter[T]:
             while low < high:
                 let mid = low + (high - low) / 2
                 let cmp = order[T](target, data_ptr + mid)
-                if cmp < 0:
-                    high = mid
-                else if cmp > 0:
-                    low = mid + 1
-                else:
-                    return Option[ptr_uint].some(value = mid)
+                if cmp < 0: high = mid else if cmp > 0: low = mid + 1 else: return Option[ptr_uint].some(value = mid)
 
             return Option[ptr_uint].none
 
 
-    public function binary_search_by(target: ptr[T], comparator: proc(target: ptr[T], element: ptr[T]) -> int) -> Option[ptr_uint]:
+    public function binary_search_by(
+        target: ptr[T],
+        comparator: proc(target: ptr[T], element: ptr[T]) -> int
+    ) -> Option[ptr_uint]:
         let data = this.data else:
             fatal(c"vec.binary_search_by missing storage")
 
@@ -440,11 +436,6 @@ extending Iter[T]:
             while low < high:
                 let mid = low + (high - low) / 2
                 let cmp = comparator(target, data_ptr + mid)
-                if cmp < 0:
-                    high = mid
-                else if cmp > 0:
-                    low = mid + 1
-                else:
-                    return Option[ptr_uint].some(value = mid)
+                if cmp < 0: high = mid else if cmp > 0: low = mid + 1 else: return Option[ptr_uint].some(value = mid)
 
             return Option[ptr_uint].none

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.4.23
+  version: 0.4.25
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -387,6 +387,7 @@ files:
 - lib/milk_tea/tooling/cli/commands/parse.rb
 - lib/milk_tea/tooling/cli/commands/run.rb
 - lib/milk_tea/tooling/cli/commands/snapshot.rb
+- lib/milk_tea/tooling/cli/commands/std.rb
 - lib/milk_tea/tooling/cli/commands/test.rb
 - lib/milk_tea/tooling/cli/commands/toolchain.rb
 - lib/milk_tea/tooling/debug_info_formatter.rb
@@ -411,6 +412,7 @@ files:
 - lib/milk_tea/tooling/run.rb
 - lib/milk_tea/tooling/sexpr_dumper.rb
 - lib/milk_tea/tooling/sexpr_parser.rb
+- lib/milk_tea/tooling/std_catalog.rb
 - lib/milk_tea/tooling/templates/wasm_shell.html
 - lib/milk_tea/tooling/toolchain_cli.rb
 - lib/milk_tea/tooling/views/404.erb
@@ -630,7 +632,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.4.23 installed!
+  Milk Tea 0.4.25 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH
@@ -652,7 +654,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.18
+rubygems_version: 4.0.16
 specification_version: 4
 summary: The Milk Tea programming language compiler toolchain
 test_files: []