---

yaml
---
r: 190223
b: refs/heads/tmp
c: da054a5
h: refs/heads/master
i:
  190221: 668ac34
  190219: 9ad4151
  190215: 28824d6
  190207: f1e9531
v: v3

Author: Manishearth

[refs]

@@ -34,6 +34,6 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 4e25765aa2b973a4dda1f61dd8b5f167752e74ef
+refs/heads/tmp: da054a5f87cb857e0c1b8684d32bb04064b9aaf1
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: d3c49d2140fc65e8bb7d7cf25bfe74dda6ce5ecf

branches/tmp/mk/main.mk

@@ -30,8 +30,8 @@ CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)

branches/tmp/src/compiletest/compiletest.rs

@@ -20,7 +20,6 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(core)]
-#![feature(path)]
 #![feature(io)]
 #![feature(net)]
 #![feature(path_ext)]

branches/tmp/src/compiletest/procsrv.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(deprecated)] // for old path, for dynamic_lib
+
 use std::process::{ExitStatus, Command, Child, Output, Stdio};
 use std::io::prelude::*;
 use std::dynamic_lib::DynamicLibrary;

branches/tmp/src/etc/gdb_rust_pretty_printing.py

@@ -27,9 +27,18 @@ def rust_pretty_printer_lookup_function(val):
     if type_code == gdb.TYPE_CODE_STRUCT:
         struct_kind = classify_struct(val.type)
 
+        if struct_kind == STRUCT_KIND_SLICE:
+            return RustSlicePrinter(val)
+
         if struct_kind == STRUCT_KIND_STR_SLICE:
             return RustStringSlicePrinter(val)
 
+        if struct_kind == STRUCT_KIND_STD_VEC:
+            return RustStdVecPrinter(val)
+
+        if struct_kind == STRUCT_KIND_STD_STRING:
+            return RustStdStringPrinter(val)
+
         if struct_kind == STRUCT_KIND_TUPLE:
             return RustTuplePrinter(val)
 
@@ -172,6 +181,28 @@ def children(self):
     def display_hint(self):
         return "array"
 
+class RustSlicePrinter:
+    def __init__(self, val):
+        self.val = val
+
+    def display_hint(self):
+        return "array"
+
+    def to_string(self):
+        length = int(self.val["length"])
+        return self.val.type.tag + ("(len: %i)" % length)
+
+    def children(self):
+        cs = []
+        length = int(self.val["length"])
+        data_ptr = self.val["data_ptr"]
+        assert data_ptr.type.code == gdb.TYPE_CODE_PTR
+        pointee_type = data_ptr.type.target()
+
+        for index in range(0, length):
+            cs.append((str(index), (data_ptr + index).dereference()))
+
+        return cs
 
 class RustStringSlicePrinter:
     def __init__(self, val):
@@ -181,6 +212,35 @@ def to_string(self):
         slice_byte_len = self.val["length"]
         return '"%s"' % self.val["data_ptr"].string(encoding="utf-8", length=slice_byte_len)
 
+class RustStdVecPrinter:
+    def __init__(self, val):
+        self.val = val
+
+    def display_hint(self):
+        return "array"
+
+    def to_string(self):
+        length = int(self.val["len"])
+        cap = int(self.val["cap"])
+        return self.val.type.tag + ("(len: %i, cap: %i)" % (length, cap))
+
+    def children(self):
+        cs = []
+        (length, data_ptr) = extract_length_and_data_ptr_from_std_vec(self.val)
+        pointee_type = data_ptr.type.target()
+
+        for index in range(0, length):
+            cs.append((str(index), (data_ptr + index).dereference()))
+        return cs
+
+class RustStdStringPrinter:
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        (length, data_ptr) = extract_length_and_data_ptr_from_std_vec(self.val["vec"])
+        return '"%s"' % data_ptr.string(encoding="utf-8", length=length)
+
 
 class RustCStyleEnumPrinter:
     def __init__(self, val):
@@ -204,19 +264,38 @@ def to_string(self):
 STRUCT_KIND_TUPLE_VARIANT   = 3
 STRUCT_KIND_STRUCT_VARIANT  = 4
 STRUCT_KIND_CSTYLE_VARIANT  = 5
-STRUCT_KIND_STR_SLICE       = 6
+STRUCT_KIND_SLICE           = 6
+STRUCT_KIND_STR_SLICE       = 7
+STRUCT_KIND_STD_VEC         = 8
+STRUCT_KIND_STD_STRING      = 9
 
 
 def classify_struct(type):
+    # print("\nclassify_struct: tag=%s\n" % type.tag)
     if type.tag == "&str":
         return STRUCT_KIND_STR_SLICE
 
+    if type.tag.startswith("&[") and type.tag.endswith("]"):
+        return STRUCT_KIND_SLICE
+
     fields = list(type.fields())
     field_count = len(fields)
 
     if field_count == 0:
         return STRUCT_KIND_REGULAR_STRUCT
 
+    if (field_count == 3 and
+        fields[0].name == "ptr" and
+        fields[1].name == "len" and
+        fields[2].name == "cap" and
+        type.tag.startswith("Vec<")):
+        return STRUCT_KIND_STD_VEC
+
+    if (field_count == 1 and
+        fields[0].name == "vec" and
+        type.tag == "String"):
+        return STRUCT_KIND_STD_STRING
+
     if fields[0].name == "RUST$ENUM$DISR":
         if field_count == 1:
             return STRUCT_KIND_CSTYLE_VARIANT
@@ -254,3 +333,11 @@ def get_field_at_index(val, index):
             return field
         i += 1
     return None
+
+def extract_length_and_data_ptr_from_std_vec(vec_val):
+    length = int(vec_val["len"])
+    vec_ptr_val = vec_val["ptr"]
+    unique_ptr_val = vec_ptr_val[first_field(vec_ptr_val)]
+    data_ptr = unique_ptr_val[first_field(unique_ptr_val)]
+    assert data_ptr.type.code == gdb.TYPE_CODE_PTR
+    return (length, data_ptr)

branches/tmp/src/etc/lldb_rust_formatters.py

@@ -40,31 +40,12 @@ def print_struct_val(val, internal_dict):
 
     if is_vec_slice(val):
         return print_vec_slice_val(val, internal_dict)
+    elif is_std_vec(val):
+        return print_std_vec_val(val, internal_dict)
     else:
         return print_struct_val_starting_from(0, val, internal_dict)
 
 
-def print_vec_slice_val(val, internal_dict):
-    length = val.GetChildAtIndex(1).GetValueAsUnsigned()
-
-    data_ptr_val = val.GetChildAtIndex(0)
-    data_ptr_type = data_ptr_val.GetType()
-    assert data_ptr_type.IsPointerType()
-
-    element_type = data_ptr_type.GetPointeeType()
-    element_type_size = element_type.GetByteSize()
-
-    start_address = data_ptr_val.GetValueAsUnsigned()
-
-    def render_element(i):
-        address = start_address + i * element_type_size
-        element_val = val.CreateValueFromAddress(val.GetName() +
-                                                 ("[%s]" % i), address, element_type)
-        return print_val(element_val, internal_dict)
-
-    return "&[%s]" % (', '.join([render_element(i) for i in range(length)]))
-
-
 def print_struct_val_starting_from(field_start_index, val, internal_dict):
     '''
     Prints a struct, tuple, or tuple struct value with Rust syntax.
@@ -100,6 +81,16 @@ def render_child(child_index):
             this += field_name + ": "
 
         field_val = val.GetChildAtIndex(child_index)
+
+        if not field_val.IsValid():
+            field = t.GetFieldAtIndex(child_index)
+            # LLDB is not good at handling zero-sized values, so we have to help
+            # it a little
+            if field.GetType().GetByteSize() == 0:
+                return this + extract_type_name(field.GetType().GetName())
+            else:
+                return this + "<invalid value>"
+
         return this + print_val(field_val, internal_dict)
 
     body = separator.join([render_child(idx) for idx in range(field_start_index, num_children)])
@@ -195,6 +186,30 @@ def print_fixed_size_vec_val(val, internal_dict):
     return output
 
 
+def print_vec_slice_val(val, internal_dict):
+    length = val.GetChildAtIndex(1).GetValueAsUnsigned()
+
+    data_ptr_val = val.GetChildAtIndex(0)
+    data_ptr_type = data_ptr_val.GetType()
+
+    return "&[%s]" % print_array_of_values(val.GetName(),
+                                           data_ptr_val,
+                                           length,
+                                           internal_dict)
+
+
+def print_std_vec_val(val, internal_dict):
+    length = val.GetChildAtIndex(1).GetValueAsUnsigned()
+
+    # Vec<> -> Unique<> -> NonZero<> -> *T
+    data_ptr_val = val.GetChildAtIndex(0).GetChildAtIndex(0).GetChildAtIndex(0)
+    data_ptr_type = data_ptr_val.GetType()
+
+    return "vec![%s]" % print_array_of_values(val.GetName(),
+                                              data_ptr_val,
+                                              length,
+                                              internal_dict)
+
 #=--------------------------------------------------------------------------------------------------
 # Helper Functions
 #=--------------------------------------------------------------------------------------------------
@@ -243,3 +258,44 @@ def is_vec_slice(val):
 
     type_name = extract_type_name(ty.GetName()).replace("&'static", "&").replace(" ", "")
     return type_name.startswith("&[") and type_name.endswith("]")
+
+def is_std_vec(val):
+    ty = val.GetType()
+    if ty.GetTypeClass() != lldb.eTypeClassStruct:
+        return False
+
+    if ty.GetNumberOfFields() != 3:
+        return False
+
+    if ty.GetFieldAtIndex(0).GetName() != "ptr":
+        return False
+
+    if ty.GetFieldAtIndex(1).GetName() != "len":
+        return False
+
+    if ty.GetFieldAtIndex(2).GetName() != "cap":
+        return False
+
+    return ty.GetName().startswith("collections::vec::Vec<")
+
+
+def print_array_of_values(array_name, data_ptr_val, length, internal_dict):
+    '''Prints a contigous memory range, interpreting it as values of the
+       pointee-type of data_ptr_val.'''
+
+    data_ptr_type = data_ptr_val.GetType()
+    assert data_ptr_type.IsPointerType()
+
+    element_type = data_ptr_type.GetPointeeType()
+    element_type_size = element_type.GetByteSize()
+
+    start_address = data_ptr_val.GetValueAsUnsigned()
+
+    def render_element(i):
+        address = start_address + i * element_type_size
+        element_val = data_ptr_val.CreateValueFromAddress(array_name + ("[%s]" % i),
+                                                          address,
+                                                          element_type)
+        return print_val(element_val, internal_dict)
+
+    return ', '.join([render_element(i) for i in range(length)])

branches/tmp/src/librustc/lib.rs

@@ -40,7 +40,6 @@
 #![feature(unsafe_destructor)]
 #![feature(staged_api)]
 #![feature(std_misc)]
-#![feature(path)]
 #![feature(io)]
 #![feature(path_ext)]
 #![feature(str_words)]

branches/tmp/src/librustc/plugin/load.rs

@@ -18,7 +18,10 @@ use std::borrow::ToOwned;
 use std::dynamic_lib::DynamicLibrary;
 use std::env;
 use std::mem;
+
+#[allow(deprecated)]
 use std::old_path;
+
 use std::path::PathBuf;
 use syntax::ast;
 use syntax::codemap::{Span, COMMAND_LINE_SP};
@@ -100,6 +103,7 @@ impl<'a> PluginLoader<'a> {
     }
 
     // Dynamically link a registrar function into the compiler process.
+    #[allow(deprecated)] // until #23197
     fn dylink_registrar(&mut self,
                         span: Span,
                         path: PathBuf,

branches/tmp/src/librustc_back/fs.rs

@@ -11,6 +11,7 @@
 use std::io;
 use std::old_io::fs;
 use std::old_io;
+#[allow(deprecated)]
 use std::old_path;
 use std::os;
 use std::path::{Path, PathBuf};

branches/tmp/src/librustc_back/lib.rs

@@ -42,11 +42,12 @@
 #![feature(old_io)]
 #![feature(old_path)]
 #![feature(os)]
-#![feature(path)]
 #![feature(rustc_private)]
 #![feature(staged_api)]
 #![feature(rand)]
 #![feature(path_ext)]
+#![feature(std_misc)]
+#![feature(path_relative_from)]
 
 extern crate syntax;
 extern crate serialize;

branches/tmp/src/librustc_driver/lib.rs

@@ -37,7 +37,6 @@
 #![feature(unsafe_destructor)]
 #![feature(staged_api)]
 #![feature(exit_status)]
-#![feature(path)]
 #![feature(io)]
 
 extern crate arena;

branches/tmp/src/librustc_llvm/lib.rs

@@ -31,7 +31,6 @@
 #![feature(libc)]
 #![feature(link_args)]
 #![feature(staged_api)]
-#![feature(path)]
 #![cfg_attr(unix, feature(std_misc))]
 
 extern crate libc;

branches/tmp/src/librustc_trans/lib.rs

@@ -39,10 +39,10 @@
 #![feature(staged_api)]
 #![feature(unicode)]
 #![feature(io)]
-#![feature(path)]
 #![feature(path_ext)]
 #![feature(fs)]
 #![feature(hash)]
+#![feature(path_relative_from)]
 
 extern crate arena;
 extern crate flate;

branches/tmp/src/librustdoc/lib.rs

@@ -37,9 +37,9 @@
 #![feature(unicode)]
 #![feature(str_words)]
 #![feature(io)]
-#![feature(path)]
 #![feature(file_path)]
 #![feature(path_ext)]
+#![feature(path_relative_from)]
 
 extern crate arena;
 extern crate getopts;
@@ -362,6 +362,7 @@ fn parse_externs(matches: &getopts::Matches) -> Result<core::Externs, String> {
 /// generated from the cleaned AST of the crate.
 ///
 /// This form of input will run all of the plug/cleaning passes
+#[allow(deprecated)] // for old Path in plugin manager
 fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matches) -> Output {
     let mut default_passes = !matches.opt_present("no-defaults");
     let mut passes = matches.opt_strs("passes");