Mojo oss release 2024 04 05 210926699 fixup

docs/changelog-released.md

@@ -1161,7 +1161,6 @@ installation issues. Otherwise it is functionally identical to Mojo 24.1.
       fn __copyinit__(inout self: Self, existing: Self):
           self.vec = existing.vec
 
-
   fn main():
       var foo = Foo()
       print(len(foo.vec))

docs/changelog.md

@@ -15,6 +15,21 @@ and tools. Please add any significant user-visible changes here.
 
 ### ⭐️ New
 
+- Heterogenous variadic pack arguments now work reliably even with memory types,
+  and have a more convenient API to use, as defined on the `VariadicPack` type.
+  For example, a simplified version of `print` can be implemented as:
+
+  ```mojo
+  fn print[T: Stringable, *Ts: Stringable](first: T, *rest: *Ts):
+      print_string(str(first))
+
+      @parameter
+      fn print_elt[T: Stringable](a: T):
+          print_string(" ")
+          print_string(a)
+      rest.each[print_elt]()
+  ```
+
 - The `sys` module now contains an `exit` function that would exit a Mojo
   program with the specified error code.
 
@@ -31,6 +46,25 @@ and tools. Please add any significant user-visible changes here.
   shorter alias is equivalent to writing `--debug-level full`. This option is
   also available in the `mojo debug` command, but is already the default.
 
+- `PythonObject` now conforms to the `KeyElement` trait, meaning that it can be
+  used as key type for `Dict`. This allows on to easily build and interact with
+  Python dictionaries in mojo:
+
+  ```mojo
+  def main():
+      d = PythonObject(Dict[PythonObject, PythonObject]())
+      d["foo"] = 12
+      d[7] = "bar"
+      d["foo"] = [1, 2, "something else"]
+      print(d)  # prints `{'foo': [1, 2, 'something else'], 7: 'bar'}`
+  ```
+
+- `List` now has a `pop(index)` API for removing an element
+  at a particular index.  By default, `List.pop()` removes the last element
+  in the list.
+
+- `Dict` now has a `update()` method to update keys/values from another `Dict`.
+
 ### 🦋 Changed
 
 - The behavior of `mojo build` when invoked without an output `-o` argument has
@@ -46,8 +80,39 @@ and tools. Please add any significant user-visible changes here.
 
 ### ❌ Removed
 
+- Support for "register only" variadic packs has been removed. Instead of
+  `AnyRegType`, please upgrade your code to `AnyType` in examples like this:
+
+  ```mojo
+  fn [*Types: AnyRegType](*args: *Ts): ...
+  ```
+
+  This move gives you access to nicer API and has the benefit of being memory
+  safe and correct for non-trivial types.  If you need specific APIs on the
+  types, please use the correct trait bound instead of `AnyType`.
+
+- `List.pop_back()` has been removed.  Use `List.pop()` instead which defaults
+  to popping the last element in the list.
+
 ### 🛠️ Fixed
 
 - [#1987](https://github.com/modularml/mojo/issues/1987) Defining `main`
   in a Mojo package is an error, for now. This is not intended to work yet,
   erroring for now will help to prevent accidental undefined behavior.
+
+- [#1215](https://github.com/modularml/mojo/issues/1215) and
+  [#1949](https://github.com/modularml/mojo/issues/1949) The Mojo LSP server no
+  longer cuts off hover previews for functions with functional arguments,
+  parameters, or results.
+
+- [#1901](https://github.com/modularml/mojo/issues/1901) Fixed Mojo LSP and
+  documentation generation handling of inout arguments.
+
+- [#1913](https://github.com/modularml/mojo/issues/1913) - `0__` no longer
+  crashes the Mojo parser.
+
+- [#1924](https://github.com/modularml/mojo/issues/1924) JIT debugging on Mac
+  has been fixed.
+
+- [#1963](https://github.com/modularml/mojo/issues/1963) `a!=0` is now parsed
+  and formatted correctly by `mojo format`.

docs/manual/get-started/index.md

@@ -188,13 +188,6 @@ brew upgrade modular
 Instead of downloading the Mojo SDK, you can also experiment with Mojo in our
 online [Playground](/mojo/playground).
 
-:::note
-
-The older [JupyterLab-based Playground](https://playground.modular.com) is still
-available until March 20th.
-
-:::
-
 ### What to expect
 
 The Mojo Playground is a simple online editor where you can test out Mojo

stdlib/docs/style-guide.md

@@ -122,6 +122,13 @@ struct MyStruct(Sized, Stringable):
 
 ## Code conventions
 
+### Python Standard Library
+
+We want to be a good member of the Python family and aim to become a full
+superset, so we inherit naming from the Python standard library, including any
+inconsistencies. These naming inconsistencies are the only exceptions to the
+naming conventions outlined below.
+
 ### Identifier naming conventions
 
 There are several ways to capitalize and separate words, known as "case

stdlib/src/builtin/builtin_list.mojo

@@ -36,7 +36,7 @@ struct ListLiteral[*Ts: AnyRegType](Sized):
     """The underlying storage for the list."""
 
     @always_inline("nodebug")
-    fn __init__(inout self, *args: *Ts):
+    fn __init__(inout self, borrowed *args: *Ts):
         """Construct the list literal from the given values.
 
         Args:
@@ -419,7 +419,6 @@ struct VariadicPack[
     lifetime: AnyLifetime[elt_is_mutable].type,
     element_trait: _AnyTypeMetaType,
     *element_types: element_trait,
-    # TODO: Add address_space when Reference supports it.
 ](Sized):
     """A utility class to access variadic pack  arguments and provide an API for
     doing things with them.
@@ -487,9 +486,15 @@ struct VariadicPack[
         Returns:
             The number of elements in the variadic pack.
         """
-        return __mlir_attr[
-            `#kgen.param.expr<variadic_size,`, element_types, `> : index`
-        ]
+
+        @parameter
+        fn variadic_size(
+            x: __mlir_type[`!kgen.variadic<`, element_trait, `>`]
+        ) -> Int:
+            return __mlir_op.`pop.variadic.size`(x)
+
+        alias result = variadic_size(element_types)
+        return result
 
     @always_inline
     fn __len__(self) -> Int:
@@ -504,13 +509,7 @@ struct VariadicPack[
     fn get_element[
         index: Int
     ](self) -> Reference[
-        # FIXME: Shouldn't need a rebind here.
-        __mlir_attr[
-            `#kgen.param.expr<rebind, `,
-            element_types[index.value],
-            `>: `,
-            AnyType,
-        ],
+        element_types[index.value],
         Self.elt_is_mutable,
         Self.lifetime,
     ]:
@@ -523,25 +522,22 @@ struct VariadicPack[
             A reference to the element.  The Reference's mutability follows the
             mutability of the pack argument convention.
         """
+        var ref_elt = __mlir_op.`lit.ref.pack.get`[index = index.value](
+            self._value
+        )
+
+        # Rebind the !lit.ref to agree on the element type.  This is needed
+        # because we're getting a low level rebind to AnyType when the
+        # element_types[index] expression is erased to AnyType for Reference.
+        alias result_ref = Reference[
+            element_types[index.value],
+            Self.elt_is_mutable,
+            Self.lifetime,
+        ]
+        return rebind[result_ref.mlir_ref_type](ref_elt)
 
-        return rebind[
-            Reference[
-                # FIXME: Shouldn't need a rebind here.
-                __mlir_attr[
-                    `#kgen.param.expr<rebind, `,
-                    element_types[index.value],
-                    `>: `,
-                    AnyType,
-                ],
-                Self.elt_is_mutable,
-                Self.lifetime,
-            ]
-        ](__mlir_op.`lit.ref.pack.get`[index = index.value](self._value))
-
-    # FIXME!: the T in the function should be element_trait bound not AnyType
-    # bound.
     @always_inline
-    fn each[func: fn[T: AnyType] (T) -> None](self):
+    fn each[func: fn[T: element_trait] (T) capturing -> None](self):
         """Apply a function to each element of the pack in order.  This applies
         the specified function (which must be parametric on the element type) to
         each element of the pack, from the first element to the last, passing

stdlib/src/builtin/int.mojo

@@ -616,7 +616,7 @@ struct Int(Intable, Stringable, KeyElement, Boolable):
         var x = self
         var n = rhs
         while n > 0:
-            if n&1 != 0:
+            if n & 1 != 0:
                 res *= x
             x *= x
             n >>= 1

stdlib/src/builtin/io.mojo

@@ -99,7 +99,7 @@ fn _flush():
 
 
 @no_inline
-fn _printf[*types: AnyRegType](fmt: StringLiteral, *arguments: *types):
+fn _printf[*types: AnyRegType](fmt: StringLiteral, borrowed *arguments: *types):
     with _fdopen(_fdopen.STDOUT) as fd:
         _ = __mlir_op.`pop.external_call`[
             func = "KGEN_CompilerRT_fprintf".value,
@@ -121,7 +121,12 @@ fn _printf[*types: AnyRegType](fmt: StringLiteral, *arguments: *types):
 @no_inline
 fn _snprintf[
     *types: AnyRegType
-](str: Pointer[Int8], size: Int, fmt: StringLiteral, *arguments: *types) -> Int:
+](
+    str: Pointer[Int8],
+    size: Int,
+    fmt: StringLiteral,
+    borrowed *arguments: *types,
+) -> Int:
     """Writes a format string into an output pointer.
 
     Args:
@@ -337,70 +342,6 @@ fn _put(x: DType):
 # ===----------------------------------------------------------------------=== #
 
 
-struct _StringableTuple[*Ts: Stringable](Sized):
-    alias _type = __mlir_type[
-        `!kgen.pack<:variadic<`, Stringable, `> `, Ts, `>`
-    ]
-    var storage: Self._type
-
-    fn __init__(inout self, value: Self._type):
-        self.storage = value
-
-    @staticmethod
-    fn _offset[i: Int]() -> Int:
-        constrained[i >= 0, "index must be positive"]()
-
-        @parameter
-        if i == 0:
-            return 0
-        else:
-            return _align_up(
-                Self._offset[i - 1]()
-                + _align_up(sizeof[Ts[i - 1]](), alignof[Ts[i - 1]]()),
-                alignof[Ts[i]](),
-            )
-
-    @always_inline
-    fn _print[i: Int](inout self, /, *, sep: StringLiteral = " "):
-        _put(sep)
-        _put(self._at[i]())
-
-    fn _at[i: Int](inout self) -> String:
-        alias offset = Self._offset[i]()
-        var i8ptr = Pointer.address_of(self).bitcast[Int8]().offset(offset)
-        return str(Reference(i8ptr[]).bitcast_element[Ts[i]]()[])
-
-    fn __len__(self) -> Int:
-        return len(VariadicList(Ts))
-
-
-@always_inline
-fn _print_elements[
-    T: Stringable, *Ts: Stringable
-](
-    first: T,
-    inout rest: _StringableTuple[Ts],
-    sep: StringLiteral = " ",
-    end: StringLiteral = "\n",
-    flush: Bool = False,
-):
-    _put(str(first))
-
-    @parameter
-    fn each[i: Int]():
-        rest._print[i](sep=sep)
-
-    unroll[each, len(VariadicList(Ts))]()
-    _put(end)
-    if flush:
-        _flush()
-
-
-# ===----------------------------------------------------------------------=== #
-#  print
-# ===----------------------------------------------------------------------=== #
-
-
 @no_inline
 fn print(
     *, sep: StringLiteral = " ", end: StringLiteral = "\n", flush: Bool = False
@@ -441,7 +382,15 @@ fn print[
         end: The String to write after printing the elements.
         flush: If set to true, then the stream is forcibly flushed.
     """
-    var vals = _StringableTuple[Ts](rest)
-    _print_elements(first, vals, sep=sep, end=end)
+    _put(str(first))
+
+    @parameter
+    fn print_elt[T: Stringable](a: T):
+        _put(sep)
+        _put(a)
+
+    rest.each[print_elt]()
+
+    _put(end)
     if flush:
         _flush()

stdlib/src/builtin/simd.mojo

@@ -1333,7 +1333,8 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
         *mask: Int, output_size: Int = size
     ](self, other: Self) -> SIMD[type, output_size]:
         """Shuffles (also called blend) the values of the current vector with
-        the `other` value using the specified mask (permutation).
+        the `other` value using the specified mask (permutation). The mask values
+        must be within `2*len(self)`.
 
         Parameters:
             mask: The permutation to use in the shuffle.
@@ -1368,6 +1369,10 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
             @parameter
             fn fill[idx: Int]():
                 alias val = mask[idx]
+                constrained[
+                    0 <= val < 2 * size,
+                    "invalid index in the shuffle operation",
+                ]()
                 var ptr = __mlir_op.`pop.array.gep`(
                     Pointer.address_of(array).address, idx.value
                 )
@@ -1391,7 +1396,8 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
     @always_inline("nodebug")
     fn shuffle[*mask: Int](self) -> Self:
         """Shuffles (also called blend) the values of the current vector with
-        the `other` value using the specified mask (permutation).
+        the `other` value using the specified mask (permutation). The mask values
+        must be within `2*len(self)`.
 
         Parameters:
             mask: The permutation to use in the shuffle.
@@ -1405,7 +1411,8 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
     @always_inline("nodebug")
     fn shuffle[*mask: Int](self, other: Self) -> Self:
         """Shuffles (also called blend) the values of the current vector with
-        the `other` value using the specified mask (permutation).
+        the `other` value using the specified mask (permutation). The mask values
+        must be within `2*len(self)`.
 
         Parameters:
             mask: The permutation to use in the shuffle.
@@ -2218,7 +2225,7 @@ fn _pow[
                 var x = lhs[i]
                 var n = rhs[i]
                 while n > 0:
-                    if n&1 != 0:
+                    if n & 1 != 0:
                         res *= x
                     x *= x
                     n >>= 1