---

yaml
---
r: 124647
b: refs/heads/try
c: 06c7ee9
h: refs/heads/master
i:
  124645: 23985ca
  124643: 7979e90
  124639: 1c2f4d7
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: f15d6d28396e8700b6c3f2704204a2769e710403
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9fc8394d3bce22ab483f98842434c84c396212ae
-refs/heads/try: 80ef6b83ef68713a255ee29b8ce326b5145e2135
+refs/heads/try: 06c7ee9c56f7c768be94c89f699527b44be664ab
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/compiletest/compiletest.rs

@@ -30,7 +30,7 @@ use std::io::fs;
 use std::from_str::FromStr;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
-use common::{Pretty, DebugInfoGdb, Codegen};
+use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen};
 use util::logv;
 use regex::Regex;
 
@@ -241,6 +241,16 @@ pub fn run_tests(config: &Config) {
         os::setenv("RUST_TEST_TASKS","1");
     }
 
+    match config.mode {
+        DebugInfoLldb => {
+            // Some older versions of LLDB seem to have problems with multiple
+            // instances running in parallel, so only run one test task at a
+            // time.
+            os::setenv("RUST_TEST_TASKS", "1");
+        }
+        _ => { /* proceed */ }
+    }
+
     let opts = test_opts(config);
     let tests = make_tests(config);
     // sadly osx needs some file descriptor limits raised for running tests in

branches/try/src/compiletest/runtest.rs

@@ -536,6 +536,16 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     // We don't want to hang when calling `quit` while the process is still running
     let mut script_str = String::from_str("settings set auto-confirm true\n");
 
+    // Make LLDB emit its version, so we have it documented in the test output
+    script_str.push_str("version\n");
+
+    // Switch LLDB into "Rust mode"
+    script_str.push_str("command script import ./src/etc/lldb_rust_formatters.py\n");
+    script_str.push_str("type summary add --no-value ");
+    script_str.push_str("--python-function lldb_rust_formatters.print_val ");
+    script_str.push_str("-x \".*\" --category Rust\n");
+    script_str.push_str("type category enable Rust\n");
+
     // Set breakpoints on every line that contains the string "#break"
     for line in breakpoint_lines.iter() {
         script_str.push_str(format!("breakpoint set --line {}\n",

branches/try/src/etc/lldb_batchmode.py

@@ -31,9 +31,6 @@
 import re
 import atexit
 
-# Terminate the debugger
-atexit.register(lambda: lldb.SBDebugger.Terminate())
-
 # Set this to True for additional output
 DEBUG_OUTPUT = False
 

branches/try/src/etc/lldb_rust_formatters.py

@@ -0,0 +1,232 @@
+# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+# file at the top-level directory of this distribution and at
+# http://rust-lang.org/COPYRIGHT.
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+# option. This file may not be copied, modified, or distributed
+# except according to those terms.
+
+import lldb
+
+def print_val(val, internal_dict):
+  '''Prints the given value with Rust syntax'''
+  type_class = val.GetType().GetTypeClass()
+
+  if type_class == lldb.eTypeClassStruct:
+    return print_struct_val(val, internal_dict)
+
+  if type_class == lldb.eTypeClassUnion:
+    return print_enum_val(val, internal_dict)
+
+  if type_class == lldb.eTypeClassPointer:
+    return print_pointer_val(val, internal_dict)
+
+  if type_class == lldb.eTypeClassArray:
+    return print_fixed_size_vec_val(val, internal_dict)
+
+  return val.GetValue()
+
+
+#=--------------------------------------------------------------------------------------------------
+# Type-Specialized Printing Functions
+#=--------------------------------------------------------------------------------------------------
+
+def print_struct_val(val, internal_dict):
+  '''Prints a struct, tuple, or tuple struct value with Rust syntax'''
+  assert val.GetType().GetTypeClass() == lldb.eTypeClassStruct
+
+  if is_vec_slice(val):
+    return print_vec_slice_val(val, internal_dict)
+  else:
+    return print_struct_val_starting_from(0, val, internal_dict)
+
+def print_vec_slice_val(val, internal_dict):
+  output = "&["
+
+  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()
+
+  for i in range(length):
+    address = start_address + i * element_type_size
+    element_val = val.CreateValueFromAddress( val.GetName() + ("[%s]" % i), address, element_type )
+    output += print_val(element_val, internal_dict)
+
+    if i != length - 1:
+      output += ", "
+
+  output += "]"
+  return output
+
+def print_struct_val_starting_from(field_start_index, val, internal_dict):
+  '''
+  Prints a struct, tuple, or tuple struct value with Rust syntax.
+  Ignores any fields before field_start_index.
+  '''
+  assert val.GetType().GetTypeClass() == lldb.eTypeClassStruct
+
+  t = val.GetType()
+  has_field_names = type_has_field_names(t)
+  type_name = extract_type_name(t.GetName())
+  output = ""
+
+  if not type_name.startswith("("):
+    # this is a tuple, so don't print the type name
+    output += type_name
+
+  if has_field_names:
+    output += " { \n"
+  else:
+    output += "("
+
+  num_children = val.num_children
+
+  for child_index in range(field_start_index, num_children):
+    if has_field_names:
+      field_name = t.GetFieldAtIndex(child_index).GetName()
+      output += field_name + ": "
+
+    field_val = val.GetChildAtIndex(child_index)
+    output += print_val(field_val, internal_dict)
+
+    if child_index != num_children - 1:
+      output += ", "
+
+    if has_field_names:
+      output += "\n"
+
+  if has_field_names:
+    output += "}"
+  else:
+    output += ")"
+
+  return output
+
+
+def print_enum_val(val, internal_dict):
+  '''Prints an enum value with Rust syntax'''
+
+  assert val.GetType().GetTypeClass() == lldb.eTypeClassUnion
+
+  if val.num_children == 1:
+    first_variant_name = val.GetChildAtIndex(0).GetName()
+    if first_variant_name and first_variant_name.startswith("RUST$ENCODED$ENUM$"):
+      # Try to extract the
+
+      last_separator_index = first_variant_name.rfind("$")
+      if last_separator_index == -1:
+        return "<invalid enum encoding: %s>" % first_variant_name
+
+      second_last_separator_index = first_variant_name.rfind("$", 0, last_separator_index)
+      if second_last_separator_index == -1:
+        return "<invalid enum encoding: %s>" % first_variant_name
+
+      try:
+        disr_field_index = first_variant_name[second_last_separator_index + 1 :
+                                              last_separator_index]
+        disr_field_index = int(disr_field_index)
+      except:
+        return "<invalid enum encoding: %s>" % first_variant_name
+
+      disr_val = val.GetChildAtIndex(0).GetChildAtIndex(disr_field_index).GetValueAsUnsigned()
+
+      if disr_val == 0:
+        null_variant_name = first_variant_name[last_separator_index + 1:]
+        return null_variant_name
+      else:
+        return print_struct_val_starting_from(0, val.GetChildAtIndex(0), internal_dict)
+    else:
+      return print_struct_val_starting_from(0, val.GetChildAtIndex(0), internal_dict)
+
+  # extract the discriminator value by
+  disr_val = val.GetChildAtIndex(0).GetChildAtIndex(0)
+  disr_type = disr_val.GetType()
+
+  if disr_type.GetTypeClass() != lldb.eTypeClassEnumeration:
+    return "<Invalid enum value encountered: Discriminator is not an enum>"
+
+  variant_index = disr_val.GetValueAsUnsigned()
+  return print_struct_val_starting_from(1, val.GetChildAtIndex(variant_index), internal_dict)
+
+
+def print_pointer_val(val, internal_dict):
+  '''Prints a pointer value with Rust syntax'''
+  assert val.GetType().IsPointerType()
+  sigil = "&"
+  type_name = extract_type_name(val.GetType().GetName())
+  if type_name and type_name[0:1] in ["&", "~", "*"]:
+    sigil = type_name[0:1]
+
+  return sigil + hex(val.GetValueAsUnsigned()) #print_val(val.Dereference(), internal_dict)
+
+
+def print_fixed_size_vec_val(val, internal_dict):
+  assert val.GetType().GetTypeClass() == lldb.eTypeClassArray
+
+  output = "["
+
+  for i in range(val.num_children):
+    output += print_val(val.GetChildAtIndex(i), internal_dict)
+    if i != val.num_children - 1:
+      output += ", "
+
+  output += "]"
+  return output
+
+
+#=--------------------------------------------------------------------------------------------------
+# Helper Functions
+#=--------------------------------------------------------------------------------------------------
+
+unqualified_type_markers = frozenset(["(", "[", "&", "*"])
+
+def extract_type_name(qualified_type_name):
+  '''Extracts the type name from a fully qualified path'''
+  if qualified_type_name[0] in unqualified_type_markers:
+    return qualified_type_name
+
+  end_of_search = qualified_type_name.find("<")
+  if end_of_search < 0:
+    end_of_search = len(qualified_type_name)
+
+  index = qualified_type_name.rfind("::", 0, end_of_search)
+  if index < 0:
+    return qualified_type_name
+  else:
+    return qualified_type_name[index + 2:]
+
+
+def type_has_field_names(ty):
+  '''Returns true of this is a type with field names (struct, struct-like enum variant)'''
+  # This may also be an enum variant where the first field doesn't have a name but the rest has
+  if ty.GetNumberOfFields() > 1:
+    return ty.GetFieldAtIndex(1).GetName() != None
+  else:
+    return ty.GetFieldAtIndex(0).GetName() != None
+
+
+def is_vec_slice(val):
+  ty = val.GetType()
+  if ty.GetTypeClass() != lldb.eTypeClassStruct:
+    return False
+
+  if ty.GetNumberOfFields() != 2:
+    return False
+
+  if ty.GetFieldAtIndex(0).GetName() != "data_ptr":
+    return False
+
+  if ty.GetFieldAtIndex(1).GetName() != "length":
+    return False
+
+  type_name = extract_type_name(ty.GetName()).replace("&'static", "&").replace(" ", "")
+  return type_name.startswith("&[") and type_name.endswith("]")

branches/try/src/etc/vim/doc/rust.txt

@@ -1,7 +1,7 @@
 *rust.txt*      Filetype plugin for Rust
 
 ==============================================================================
-CONTENTS                                                                *rust*
+CONTENTS                                                      *rust* *ft-rust*
 
 1. Introduction                                                   |rust-intro|
 2. Settings                                                    |rust-settings|
@@ -53,6 +53,18 @@ g:rust_conceal_pub~
 	    let g:rust_conceal_pub = 1
 <
 
+                                                                 *g:rust_fold*
+g:rust_fold~
+	Set this option to turn on |folding|: >
+	    let g:rust_fold = 1
+<
+	Value		Effect ~
+	0		No folding
+	1		Braced blocks are folded. All folds are open by
+			default.
+	2		Braced blocks are folded. 'foldlevel' is left at the
+			global value (all folds are closed by default).
+
                                                   *g:rust_bang_comment_leader*
 g:rust_bang_comment_leader~
 	Set this option to 1 to preserve the leader on multi-line doc comments

branches/try/src/etc/vim/ftplugin/rust.vim

@@ -2,7 +2,7 @@
 " Description:  Vim syntax file for Rust
 " Maintainer:   Chris Morgan <[email protected]>
 " Maintainer:   Kevin Ballard <[email protected]>
-" Last Change:  May 27, 2014
+" Last Change:  Jul 07, 2014
 
 if exists("b:did_ftplugin")
 	finish
@@ -35,7 +35,9 @@ silent! setlocal formatoptions+=j
 " otherwise it's better than nothing.
 setlocal smartindent nocindent
 
-setlocal tabstop=4 shiftwidth=4 expandtab
+setlocal tabstop=4 shiftwidth=4 softtabstop=4 expandtab
+
+setlocal textwidth=99
 
 " This includeexpr isn't perfect, but it's a good start
 setlocal includeexpr=substitute(v:fname,'::','/','g')
@@ -93,7 +95,8 @@ endif
 " Cleanup {{{1
 
 let b:undo_ftplugin = "
-		\setlocal formatoptions< comments< commentstring< includeexpr< suffixesadd<
+		\ setlocal formatoptions< comments< commentstring< includeexpr< suffixesadd<
+		\|setlocal tabstop< shiftwidth< softtabstop< expandtab< textwidth<
 		\|if exists('b:rust_original_delimitMate_excluded_regions')
 		  \|let b:delimitMate_excluded_regions = b:rust_original_delimitMate_excluded_regions
 		  \|unlet b:rust_original_delimitMate_excluded_regions

branches/try/src/etc/vim/syntax/rust.vim

@@ -3,14 +3,25 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2014 Feb 27
+" Last Change:  July 06, 2014
 
 if version < 600
   syntax clear
 elseif exists("b:current_syntax")
   finish
 endif
 
+" Fold settings {{{1
+
+if has("folding") && exists('g:rust_fold') && g:rust_fold != 0
+  setlocal foldmethod=syntax
+  if g:rust_fold == 2
+    setlocal foldlevel<
+  else
+    setlocal foldlevel=99
+  endif
+endif
+
 " Syntax definitions {{{1
 " Basic keywords {{{2
 syn keyword   rustConditional match if else
@@ -213,8 +224,6 @@ syn keyword rustTodo contained TODO FIXME XXX NB NOTE
 " Trivial folding rules to begin with.
 " TODO: use the AST to make really good folding
 syn region rustFoldBraces start="{" end="}" transparent fold
-" If you wish to enable this, setlocal foldmethod=syntax
-" It's not enabled by default as it would drive some people mad.
 
 " Default highlighting {{{1
 hi def link rustDecNumber       rustNumber