---

yaml
---
r: 137663
b: refs/heads/auto
c: 1c6fd76
h: refs/heads/master
i:
  137661: 8c8cba0
  137659: 0f1861c
  137655: 382fd8c
  137647: e256337
  137631: e98999b
  137599: 1aa336c
v: v3

Author: thestinger

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 1b46b007d7d1acbbfb59c7e0f1307e6a378ab584
+refs/heads/auto: 1c6fd76f8073a420a82d85c45ea1697fb94d214b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -535,17 +535,13 @@ probe CFG_LLDB             lldb
 
 if [ ! -z "$CFG_GDB" ]
 then
-    # Store GDB's version
+    # Extract the version
     CFG_GDB_VERSION=$($CFG_GDB --version 2>/dev/null | head -1)
     putvar CFG_GDB_VERSION
 fi
 
 if [ ! -z "$CFG_LLDB" ]
 then
-    # Store LLDB's version
-    CFG_LLDB_VERSION=$($CFG_LLDB --version 2>/dev/null | head -1)
-    putvar CFG_LLDB_VERSION
-
     # If CFG_LLDB_PYTHON_DIR is not already set from the outside and valid, try to read it from
     # LLDB via the -P commandline options.
     if [ -z "$CFG_LLDB_PYTHON_DIR" ] || [ ! -d "$CFG_LLDB_PYTHON_DIR" ]

branches/auto/mk/tests.mk

@@ -625,7 +625,6 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
         --target $(2) \
         --host $(3) \
         --gdb-version="$(CFG_GDB_VERSION)" \
-        --lldb-version="$(CFG_LLDB_VERSION)" \
         --android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
         --adb-path=$(CFG_ADB) \
         --adb-test-dir=$(CFG_ADB_TEST_DIR) \

branches/auto/src/compiletest/common.rs

@@ -133,9 +133,6 @@ pub struct Config {
     // Version of GDB
     pub gdb_version: Option<String>,
 
-    // Version of LLDB
-    pub lldb_version: Option<String>,
-
     // Path to the android tools
     pub android_cross_path: Path,
 

branches/auto/src/compiletest/compiletest.rs

@@ -71,8 +71,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "host", "the host to build for", "HOST"),
-          optopt("", "gdb-version", "the version of GDB used", "VERSION STRING"),
-          optopt("", "lldb-version", "the version of LLDB used", "VERSION STRING"),
+          optopt("", "gdb-version", "the version of GDB used", "MAJOR.MINOR"),
           optopt("", "android-cross-path", "Android NDK standalone path", "PATH"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
@@ -150,7 +149,6 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         target: opt_str2(matches.opt_str("target")),
         host: opt_str2(matches.opt_str("host")),
         gdb_version: extract_gdb_version(matches.opt_str("gdb-version")),
-        lldb_version: extract_lldb_version(matches.opt_str("lldb-version")),
         android_cross_path: opt_path(matches, "android-cross-path"),
         adb_path: opt_str2(matches.opt_str("adb-path")),
         adb_test_dir: opt_str2(matches.opt_str("adb-test-dir")),
@@ -393,37 +391,3 @@ fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
         _ => None
     }
 }
-
-fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
-    // Extract the major LLDB version from the given version string.
-    // LLDB version strings are different for Apple and non-Apple platforms.
-    // At the moment, this function only supports the Apple variant, which looks
-    // like this:
-    //
-    // LLDB-179.5 (older versions)
-    // lldb-300.2.51 (new versions)
-    //
-    // We are only interested in the major version number, so this function
-    // will return `Some("179")` and `Some("300")` respectively.
-
-    match full_version_line {
-        Some(ref full_version_line)
-          if full_version_line.as_slice().trim().len() > 0 => {
-            let full_version_line = full_version_line.as_slice().trim();
-
-            let re = Regex::new(r"[Ll][Ll][Dd][Bb]-([0-9]+)").unwrap();
-
-            match re.captures(full_version_line) {
-                Some(captures) => {
-                    Some(captures.at(1).to_string())
-                }
-                None => {
-                    println!("Could not extract LLDB version from line '{}'",
-                             full_version_line);
-                    None
-                }
-            }
-        },
-        _ => None
-    }
-}

branches/auto/src/compiletest/header.rs

@@ -181,42 +181,14 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
         }
     }
 
-    fn ignore_lldb(config: &Config, line: &str) -> bool {
-        if config.mode != common::DebugInfoLldb {
-            return false;
-        }
-
-        if parse_name_directive(line, "ignore-lldb") {
-            return true;
-        }
-
-        match config.lldb_version {
-            Some(ref actual_version) => {
-                if line.contains("min-lldb-version") {
-                    let min_version = line.trim()
-                                          .split(' ')
-                                          .last()
-                                          .expect("Malformed lldb version directive");
-                    // Ignore if actual version is smaller the minimum required
-                    // version
-                    lldb_version_to_int(actual_version.as_slice()) <
-                        lldb_version_to_int(min_version.as_slice())
-                } else {
-                    false
-                }
-            }
-            None => false
-        }
-    }
-
     let val = iter_header(testfile, |ln| {
         !parse_name_directive(ln, "ignore-test") &&
         !parse_name_directive(ln, ignore_target(config).as_slice()) &&
         !parse_name_directive(ln, ignore_stage(config).as_slice()) &&
         !(config.mode == common::Pretty && parse_name_directive(ln, "ignore-pretty")) &&
         !(config.target != config.host && parse_name_directive(ln, "ignore-cross-compile")) &&
         !ignore_gdb(config, ln) &&
-        !ignore_lldb(config, ln)
+        !(config.mode == common::DebugInfoLldb && parse_name_directive(ln, "ignore-lldb"))
     });
 
     !val
@@ -358,12 +330,3 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
 
     return major * 1000 + minor;
 }
-
-pub fn lldb_version_to_int(version_string: &str) -> int {
-    let error_string = format!(
-        "Encountered LLDB version string with unexpected format: {}",
-        version_string);
-    let error_string = error_string.as_slice();
-    let major: int = FromStr::from_str(version_string).expect(error_string);
-    return major;
-}

branches/auto/src/compiletest/runtest.rs

@@ -626,17 +626,6 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 
     let exe_file = make_exe_name(config, testfile);
 
-    match config.lldb_version {
-        Some(ref version) => {
-            println!("NOTE: compiletest thinks it is using LLDB version {}",
-                     version.as_slice());
-        }
-        _ => {
-            println!("NOTE: compiletest does not know which version of \
-                      LLDB it is using");
-        }
-    }
-
     // Parse debugger commands etc from test files
     let DebuggerCommands {
         commands,

branches/auto/src/doc/guide-macros.md

@@ -87,7 +87,7 @@ forbidden.
 
 Otherwise, the invocation syntax is free-form.
 
-To take a fragment of Rust code as an argument, write `$` followed by a name
+To take as an argument a fragment of Rust code, write `$` followed by a name
  (for use on the right-hand side), followed by a `:`, followed by a *fragment
  specifier*. The fragment specifier denotes the sort of fragment to match. The
  most common fragment specifiers are:

branches/auto/src/doc/guide.md

@@ -5212,8 +5212,8 @@ We can check this out using a special flag to `rustc`. This code, in a file
 
 ```{rust}
 fn main() {
-    let x = 5i;
-    println!("x is: {}", x);
+    let x = "Hello";
+    println!("x is: {:s}", x);
 }
 ```
 
@@ -5225,19 +5225,32 @@ give us this huge result:
 #![no_std]
 #![feature(globs)]
 #[phase(plugin, link)]
-extern crate "std" as std;
-extern crate "native" as rt;
-#[prelude_import]
+extern crate std = "std";
+extern crate rt = "native";
 use std::prelude::*;
 fn main() {
-    let x = 5i;
+    let x = "Hello";
     match (&x,) {
         (__arg0,) => {
             #[inline]
             #[allow(dead_code)]
-            static __STATIC_FMTSTR: [&'static str, ..1u] = ["x is: "];
+            static __STATIC_FMTSTR: [::std::fmt::rt::Piece<'static>, ..2u] =
+                [::std::fmt::rt::String("x is: "),
+                 ::std::fmt::rt::Argument(::std::fmt::rt::Argument{position:
+                                                                       ::std::fmt::rt::ArgumentNext,
+                                                                   format:
+                                                                       ::std::fmt::rt::FormatSpec{fill:
+                                                                                                      ' ',
+                                                                                                  align:
+                                                                                                      ::std::fmt::rt::AlignUnknown,
+                                                                                                  flags:
+                                                                                                      0u,
+                                                                                                  precision:
+                                                                                                      ::std::fmt::rt::CountImplied,
+                                                                                                  width:
+                                                                                                      ::std::fmt::rt::CountImplied,},})];
             let __args_vec =
-                &[::std::fmt::argument(::std::fmt::secret_show, __arg0)];
+                &[::std::fmt::argument(::std::fmt::secret_string, __arg0)];
             let __args =
                 unsafe {
                     ::std::fmt::Arguments::new(__STATIC_FMTSTR, __args_vec)
@@ -5248,16 +5261,45 @@ fn main() {
 }
 ```
 
+Intense. Here's a trimmed down version that's a bit easier to read:
+
+```{rust,ignore}
+fn main() {
+    let x = 5i;
+    match (&x,) {
+        (__arg0,) => {
+            static __STATIC_FMTSTR:  =
+                [String("x is: "),
+                 Argument(Argument {
+                    position: ArgumentNext,
+                    format: FormatSpec {
+                        fill: ' ',
+                        align: AlignUnknown,
+                        flags: 0u,
+                        precision: CountImplied,
+                        width: CountImplied,
+                    },
+                },
+               ];
+            let __args_vec = &[argument(secret_string, __arg0)];
+            let __args = unsafe { Arguments::new(__STATIC_FMTSTR, __args_vec) };
+
+            println_args(&__args)
+        }
+    };
+}
+```
+
 Whew! This isn't too terrible. You can see that we still `let x = 5i`,
 but then things get a little bit hairy. Three more bindings get set: a
 static format string, an argument vector, and the arguments. We then
 invoke the `println_args` function with the generated arguments.
 
-This is the code that Rust actually compiles. You can see all of the extra
-information that's here. We get all of the type safety and options that it
-provides, but at compile time, and without needing to type all of this out.
-This is how macros are powerful. Without them, you would need to type all of
-this by hand to get a type checked `println`.
+This is the code (well, the full version) that Rust actually compiles. You can
+see all of the extra information that's here. We get all of the type safety and
+options that it provides, but at compile time, and without needing to type all
+of this out. This is how macros are powerful. Without them, you would need to
+type all of this by hand to get a type checked `println`.
 
 For more on macros, please consult [the Macros Guide](guide-macros.html).
 Macros are a very advanced and still slightly experimental feature, but don't

branches/auto/src/doc/reference.md

@@ -187,8 +187,6 @@ grammar as double-quoted strings. Other tokens have exact rules given.
 
 The keywords are the following strings, organized by first letter:
 
-<div id="keywords">
-|          |        |        |       |
 |----------|--------|--------|-------|
 | as       |        |        |       |
 |----------|--------|--------|-------|
@@ -218,7 +216,6 @@ The keywords are the following strings, organized by first letter:
 |----------|--------|--------|-------|
 | while    |        |        |       |
 |----------|--------|--------|-------|
-</div>
 
 Each of these keywords has special meaning in its grammar, and all of them are
 excluded from the `ident` rule.
@@ -1897,7 +1894,7 @@ type int8_t = i8;
 
 ### Crate-only attributes
 
-- `crate_name` - specify the this crate's crate name.
+- `crate_id` - specify the this crate's crate ID.
 - `crate_type` - see [linkage](#linkage).
 - `feature` - see [compiler features](#compiler-features).
 - `no_builtins` - disable optimizing certain code patterns to invocations of
@@ -1927,8 +1924,6 @@ type int8_t = i8;
 - `start` - indicates that this function should be used as the entry point,
   overriding the "start" language item. See the "start" [language
   item](#language-items) for more details.
-- `test` - indicates that this function is a test function, to only be compiled
-  in case of `--test`.
 
 ### Static-only attributes
 

branches/auto/src/doc/rust.css

@@ -392,5 +392,3 @@ pre.rust { position: relative; }
         background-color: #fff !important;
     }
 }
-
-#keywords table td { border: none; }

branches/auto/src/etc/gdb_rust_pretty_printing.py

@@ -196,7 +196,7 @@ def classify_struct(type):
   if field_count == 0:
     return STRUCT_KIND_REGULAR_STRUCT
 
-  if fields[0].name == "RUST$ENUM$DISR":
+  if fields[0].artificial:
     if field_count == 1:
       return STRUCT_KIND_CSTYLE_VARIANT
     elif fields[1].name == None:

branches/auto/src/etc/lldb_rust_formatters.py

@@ -117,19 +117,11 @@ def print_enum_val(val, internal_dict):
 
   assert val.GetType().GetTypeClass() == lldb.eTypeClassUnion
 
-
   if val.num_children == 1:
-    # This is either an enum with just one variant, or it is an Option-like enum
-    # where the discriminant is encoded in a non-nullable pointer field. We find
-    # out which one it is by looking at the member name of the sole union
-    # variant. If it starts with "RUST$ENCODED$ENUM$" then we have an
-    # Option-like enum.
     first_variant_name = val.GetChildAtIndex(0).GetName()
     if first_variant_name and first_variant_name.startswith("RUST$ENCODED$ENUM$"):
+      # Try to extract the
 
-      # This is an Option-like enum. The position of the discriminator field is
-      # encoded in the name which has the format:
-      #  RUST$ENCODED$ENUM$<index of discriminator field>$<name of null variant>
       last_separator_index = first_variant_name.rfind("$")
       if last_separator_index == -1:
         return "<invalid enum encoding: %s>" % first_variant_name
@@ -138,30 +130,25 @@ def print_enum_val(val, internal_dict):
       if second_last_separator_index == -1:
         return "<invalid enum encoding: %s>" % first_variant_name
 
-      # Extract index of the discriminator field
       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
 
-      # Read the discriminant
       disr_val = val.GetChildAtIndex(0).GetChildAtIndex(disr_field_index).GetValueAsUnsigned()
 
       if disr_val == 0:
-        # Null case: Print the name of the null-variant
         null_variant_name = first_variant_name[last_separator_index + 1:]
         return null_variant_name
       else:
-        # Non-null case: Interpret the data as a value of the non-null variant type
         return print_struct_val_starting_from(0, val.GetChildAtIndex(0), internal_dict)
     else:
-      # This is just a regular uni-variant enum without discriminator field
       return print_struct_val_starting_from(0, val.GetChildAtIndex(0), internal_dict)
 
-  # If we are here, this is a regular enum with more than one variant
-  disr_val = val.GetChildAtIndex(0).GetChildMemberWithName("RUST$ENUM$DISR")
+  # extract the discriminator value by
+  disr_val = val.GetChildAtIndex(0).GetChildAtIndex(0)
   disr_type = disr_val.GetType()
 
   if disr_type.GetTypeClass() != lldb.eTypeClassEnumeration:

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

@@ -54,7 +54,7 @@ syn match rustMacroRepeatCount ".\?[*+]" contained
 syn match rustMacroVariable "$\w\+"
 
 " Reserved (but not yet used) keywords {{{2
-syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield abstract final override
+syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield
 
 " Built-in types {{{2
 syn keyword   rustType        int uint float char bool u8 u16 u32 u64 f32