Auto merge of #56215 - pietroalbini:rollup, r=pietroalbini

Rollup of 14 pull requests

Successful merges:

 - #56024 (Don't auto-inline const functions)
 - #56045 (Check arg/ret sizedness at ExprKind::Path)
 - #56072 (Stabilize macro_literal_matcher)
 - #56075 (Encode a custom "producers" section in wasm files)
 - #56100 (generator fields are not necessarily initialized)
 - #56101 (Incorporate `dyn` into more comments and docs.)
 - #56144 (Fix BTreeSet and BTreeMap gdb pretty-printers)
 - #56151 (Move a flaky process test out of libstd)
 - #56170 (Fix self profiler ICE on Windows)
 - #56176 (Panic setup msg)
 - #56204 (Suggest correct enum variant on typo)
 - #56207 (Stabilize the int_to_from_bytes feature)
 - #56210 (read_c_str should call the AllocationExtra hooks)
 - #56211 ([master] Forward-ports from beta)

Failed merges:

r? @ghost

src/doc/unstable-book/src/language-features/unsized-locals.md

@@ -80,8 +80,6 @@ fn main() {
 }
 ```
 
-However, the current implementation allows `MyTupleStruct(..)` to be unsized. This will be fixed in the future.
-
 ## By-value trait objects
 
 With this feature, you can have by-value `self` arguments without `Self: Sized` bounds.

src/etc/debugger_pretty_printers_common.py

@@ -375,32 +375,6 @@ def extract_tail_head_ptr_and_cap_from_std_vecdeque(vec_val):
  assert data_ptr.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_PTR
  return (tail, head, data_ptr, capacity)
 
-
-def extract_length_and_ptr_from_std_btreeset(vec_val):
- assert vec_val.type.get_type_kind() == TYPE_KIND_STD_BTREESET
- map = vec_val.get_child_at_index(0)
- root = map.get_child_at_index(0)
- length = map.get_child_at_index(1).as_integer()
- node = root.get_child_at_index(0)
- ptr = node.get_child_at_index(0)
- unique_ptr_val = ptr.get_child_at_index(0)
- data_ptr = unique_ptr_val.get_child_at_index(0)
- assert data_ptr.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_PTR
- return (length, data_ptr)
-
-
-def extract_length_and_ptr_from_std_btreemap(vec_val):
- assert vec_val.type.get_type_kind() == TYPE_KIND_STD_BTREEMAP
- root = vec_val.get_child_at_index(0)
- length = vec_val.get_child_at_index(1).as_integer()
- node = root.get_child_at_index(0)
- ptr = node.get_child_at_index(0)
- unique_ptr_val = ptr.get_child_at_index(0)
- data_ptr = unique_ptr_val.get_child_at_index(0)
- assert data_ptr.type.get_dwarf_type_kind() == DWARF_TYPE_CODE_PTR
- return (length, data_ptr)
-
-
 def extract_length_and_ptr_from_slice(slice_val):
  assert (slice_val.type.get_type_kind() == TYPE_KIND_SLICE or
  slice_val.type.get_type_kind() == TYPE_KIND_STR_SLICE)

src/etc/gdb_rust_pretty_printing.py

@@ -319,6 +319,32 @@ def children(self):
  yield (str(index), (gdb_ptr + ((tail + index) % cap)).dereference())
 
 
+# Yield each key (and optionally value) from a BoxedNode.
+def children_of_node(boxed_node, height, want_values):
+ ptr = boxed_node['ptr']['pointer']
+ # This is written oddly because we don't want to rely on the field name being `__0`.
+ node_ptr = ptr[ptr.type.fields()[0]]
+ if height > 0:
+ type_name = str(node_ptr.type.target()).replace('LeafNode', 'InternalNode')
+ node_type = gdb.lookup_type(type_name)
+ node_ptr = node_ptr.cast(node_type.pointer())
+ leaf = node_ptr['data']
+ else:
+ leaf = node_ptr.dereference()
+ keys = leaf['keys']['value']['value']
+ if want_values:
+ values = leaf['vals']['value']['value']
+ length = int(leaf['len'])
+ for i in xrange(0, length + 1):
+ if height > 0:
+ for child in children_of_node(node_ptr['edges'][i], height - 1, want_values):
+ yield child
+ if i < length:
+ if want_values:
+ yield (keys[i], values[i])
+ else:
+ yield keys[i]
+
 class RustStdBTreeSetPrinter(object):
  def __init__(self, val):
  self.__val = val
@@ -328,21 +354,16 @@ def display_hint():
  return "array"
 
  def to_string(self):
- (length, data_ptr) = \
- rustpp.extract_length_and_ptr_from_std_btreeset(self.__val)
  return (self.__val.type.get_unqualified_type_name() +
- ("(len: %i)" % length))
+ ("(len: %i)" % self.__val.get_wrapped_value()['map']['length']))
 
  def children(self):
- (length, data_ptr) = \
- rustpp.extract_length_and_ptr_from_std_btreeset(self.__val)
- leaf_node = GdbValue(data_ptr.get_wrapped_value().dereference())
- maybe_uninit_keys = leaf_node.get_child_at_index(3)
- manually_drop_keys = maybe_uninit_keys.get_child_at_index(1)
- keys = manually_drop_keys.get_child_at_index(0)
- gdb_ptr = keys.get_wrapped_value()
- for index in xrange(length):
- yield (str(index), gdb_ptr[index])
+ root = self.__val.get_wrapped_value()['map']['root']
+ node_ptr = root['node']
+ i = 0
+ for child in children_of_node(node_ptr, root['height'], False):
+ yield (str(i), child)
+ i = i + 1
 
 
 class RustStdBTreeMapPrinter(object):
@@ -354,26 +375,17 @@ def display_hint():
  return "map"
 
  def to_string(self):
- (length, data_ptr) = \
- rustpp.extract_length_and_ptr_from_std_btreemap(self.__val)
  return (self.__val.type.get_unqualified_type_name() +
- ("(len: %i)" % length))
+ ("(len: %i)" % self.__val.get_wrapped_value()['length']))
 
  def children(self):
- (length, data_ptr) = \
- rustpp.extract_length_and_ptr_from_std_btreemap(self.__val)
- leaf_node = GdbValue(data_ptr.get_wrapped_value().dereference())
- maybe_uninit_keys = leaf_node.get_child_at_index(3)
- manually_drop_keys = maybe_uninit_keys.get_child_at_index(1)
- keys = manually_drop_keys.get_child_at_index(0)
- keys_ptr = keys.get_wrapped_value()
- maybe_uninit_vals = leaf_node.get_child_at_index(4)
- manually_drop_vals = maybe_uninit_vals.get_child_at_index(1)
- vals = manually_drop_vals.get_child_at_index(0)
- vals_ptr = vals.get_wrapped_value()
- for index in xrange(length):
- yield (str(index), keys_ptr[index])
- yield (str(index), vals_ptr[index])
+ root = self.__val.get_wrapped_value()['root']
+ node_ptr = root['node']
+ i = 0
+ for child in children_of_node(node_ptr, root['height'], True):
+ yield (str(i), child[0])
+ yield (str(i), child[1])
+ i = i + 1
 
 
 class RustStdStringPrinter(object):

src/liballoc/boxed.rs

@@ -489,7 +489,7 @@ impl Box<dyn Any> {
  /// ```
  /// use std::any::Any;
  ///
- /// fn print_if_string(value: Box<Any>) {
+ /// fn print_if_string(value: Box<dyn Any>) {
  /// if let Ok(string) = value.downcast::<String>() {
  /// println!("String ({}): {}", string.len(), string);
  /// }
@@ -523,7 +523,7 @@ impl Box<dyn Any + Send> {
  /// ```
  /// use std::any::Any;
  ///
- /// fn print_if_string(value: Box<Any + Send>) {
+ /// fn print_if_string(value: Box<dyn Any + Send>) {
  /// if let Ok(string) = value.downcast::<String>() {
  /// println!("String ({}): {}", string.len(), string);
  /// }
@@ -618,18 +618,18 @@ impl<I: FusedIterator + ?Sized> FusedIterator for Box<I> {}
 
 /// `FnBox` is a version of the `FnOnce` intended for use with boxed
 /// closure objects. The idea is that where one would normally store a
-/// `Box<FnOnce()>` in a data structure, you should use
-/// `Box<FnBox()>`. The two traits behave essentially the same, except
+/// `Box<dyn FnOnce()>` in a data structure, you should use
+/// `Box<dyn FnBox()>`. The two traits behave essentially the same, except
 /// that a `FnBox` closure can only be called if it is boxed. (Note
-/// that `FnBox` may be deprecated in the future if `Box<FnOnce()>`
+/// that `FnBox` may be deprecated in the future if `Box<dyn FnOnce()>`
 /// closures become directly usable.)
 ///
 /// # Examples
 ///
 /// Here is a snippet of code which creates a hashmap full of boxed
 /// once closures and then removes them one by one, calling each
 /// closure as it is removed. Note that the type of the closures
-/// stored in the map is `Box<FnBox() -> i32>` and not `Box<FnOnce()
+/// stored in the map is `Box<dyn FnBox() -> i32>` and not `Box<dyn FnOnce()
 /// -> i32>`.
 ///
 /// ```
@@ -638,8 +638,8 @@ impl<I: FusedIterator + ?Sized> FusedIterator for Box<I> {}
 /// use std::boxed::FnBox;
 /// use std::collections::HashMap;
 ///
-/// fn make_map() -> HashMap<i32, Box<FnBox() -> i32>> {
-/// let mut map: HashMap<i32, Box<FnBox() -> i32>> = HashMap::new();
+/// fn make_map() -> HashMap<i32, Box<dyn FnBox() -> i32>> {
+/// let mut map: HashMap<i32, Box<dyn FnBox() -> i32>> = HashMap::new();
 /// map.insert(1, Box::new(|| 22));
 /// map.insert(2, Box::new(|| 44));
 /// map

src/liballoc/rc.rs

@@ -633,15 +633,15 @@ impl<T: Clone> Rc<T> {
 impl Rc<dyn Any> {
  #[inline]
  #[stable(feature = "rc_downcast", since = "1.29.0")]
- /// Attempt to downcast the `Rc<Any>` to a concrete type.
+ /// Attempt to downcast the `Rc<dyn Any>` to a concrete type.
  ///
  /// # Examples
  ///
  /// ```
  /// use std::any::Any;
  /// use std::rc::Rc;
  ///
- /// fn print_if_string(value: Rc<Any>) {
+ /// fn print_if_string(value: Rc<dyn Any>) {
  /// if let Ok(string) = value.downcast::<String>() {
  /// println!("String ({}): {}", string.len(), string);
  /// }