---

yaml
---
r: 94158
b: refs/heads/try
c: 6de5b7a
h: refs/heads/master
v: v3

Author: jhasse

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: 0d9c0c9771e27538358adf735693dee35a105563
+refs/heads/try: 6de5b7ab1e893fb7cfdc7f7546353f34ffa58f42
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/tutorial-ffi.md

@@ -152,7 +152,7 @@ for the rust task is plenty for the C function to have.
 
 A planned future improvement (net yet implemented at the time of this writing)
 is to have a guard page at the end of every rust stack. No rust function will
-hit this guard page (due to Rust's usage of LLVM's `__morestack`). The intention
+hit this guard page (due to rust's usage of LLVM's __morestack). The intention
 for this unmapped page is to prevent infinite recursion in C from overflowing
 onto other rust stacks. If the guard page is hit, then the process will be
 terminated with a message saying that the guard page was hit.
@@ -166,39 +166,30 @@ the stack of the task which is spawned.
 
 # Destructors
 
-Foreign libraries often hand off ownership of resources to the calling code.
-When this occurs, we must use Rust's destructors to provide safety and guarantee
-the release of these resources (especially in the case of failure).
+Foreign libraries often hand off ownership of resources to the calling code,
+which should be wrapped in a destructor to provide safety and guarantee their
+release.
 
-As an example, we give a reimplementation of owned boxes by wrapping `malloc`
-and `free`:
+A type with the same functionality as owned boxes can be implemented by
+wrapping `malloc` and `free`:
 
 ~~~~
 use std::cast;
 use std::libc::{c_void, size_t, malloc, free};
 use std::ptr;
 use std::unstable::intrinsics;
 
-// Define a wrapper around the handle returned by the foreign code.
-// Unique<T> has the same semantics as ~T
+// a wrapper around the handle returned by the foreign code
 pub struct Unique<T> {
-    // It contains a single raw, mutable pointer to the object in question.
     priv ptr: *mut T
 }
 
-// Implement methods for creating and using the values in the box.
-// NB: For simplicity and correctness, we require that T has kind Send
-// (owned boxes relax this restriction, and can contain managed (GC) boxes).
-// This is because, as implemented, the garbage collector would not know
-// about any shared boxes stored in the malloc'd region of memory.
 impl<T: Send> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         unsafe {
             let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;
             assert!(!ptr::is_null(ptr));
             // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it
-            // move_val_init moves a value into this memory without
-            // attempting to drop the original value.
             intrinsics::move_val_init(&mut *ptr, value);
             Unique{ptr: ptr}
         }
@@ -215,20 +206,12 @@ impl<T: Send> Unique<T> {
     }
 }
 
-// The key ingredient for safety, we associate a destructor with
-// Unique<T>, making the struct manage the raw pointer: when the
-// struct goes out of scope, it will automatically free the raw pointer.
-// NB: This is an unsafe destructor, because rustc will not normally
-// allow destructors to be associated with parametrized types, due to
-// bad interaction with managed boxes. (With the Send restriction,
-// we don't have this problem.)
 #[unsafe_destructor]
 impl<T: Send> Drop for Unique<T> {
     fn drop(&mut self) {
         unsafe {
-            let x = intrinsics::uninit(); // dummy value to swap in
-            // We need to move the object out of the box, so that
-            // the destructor is called (at the end of this scope.)
+            let x = intrinsics::init(); // dummy value to swap in
+            // moving the object out is needed to call the destructor
             ptr::replace_ptr(self.ptr, x);
             free(self.ptr as *c_void)
         }

branches/try/doc/tutorial-rustpkg.md

@@ -198,7 +198,7 @@ Now you can install and use it! Go anywhere else in your filesystem:
 
 ~~~ {.notrust}
 $ cd ~/src/foo
-$ rustpkg install github/YOUR_USERNAME/hello
+$ rustpkg install github.com/YOUR_USERNAME/hello
 WARNING: The Rust package manager is experimental and may be unstable
 note: Installed package github.com/YOUR_USERNAME/hello-0.1 to /home/yourusername/src/hello/.rust
 ~~~

branches/try/src/etc/emacs/rust-mode-tests.el

@@ -52,24 +52,24 @@ Also, the result should be the same regardless of whether the code is at the beg
     (loop
      for pad-at-beginning from 0 to 1
      do (loop for pad-at-end from 0 to 1
-              with padding-beginning = (if (= 0 pad-at-beginning) "" padding)
-              with padding-end = (if (= 0 pad-at-end) "" padding)
-              with padding-adjust = (* padding-len pad-at-beginning)
-              with padding-beginning = (if (= 0 pad-at-beginning) "" padding)
-              with padding-end = (if (= 0 pad-at-end) "" padding)
-              ;; If we're adding space to the beginning, and our start position
-              ;; is at the very beginning, we want to test within the added space.
-              ;; Otherwise adjust the start and end for the beginning padding.
-              with start-pos = (if (= 1 start-pos) 1 (+ padding-adjust start-pos))
-              with end-pos = (+ end-pos padding-adjust)
-              do (loop for pos from start-pos to end-pos
-                       do (rust-test-manip-code
-                           (concat padding-beginning unfilled padding-end)
-                           pos
-                           (lambda () 
-                             (let ((fill-column rust-test-fill-column))
-                               (fill-paragraph)))
-                           (concat padding-beginning expected padding-end)))))))
+           with padding-beginning = (if (= 0 pad-at-beginning) "" padding)
+           with padding-end = (if (= 0 pad-at-end) "" padding)
+           with padding-adjust = (* padding-len pad-at-beginning)
+           with padding-beginning = (if (= 0 pad-at-beginning) "" padding)
+           with padding-end = (if (= 0 pad-at-end) "" padding)
+           ;; If we're adding space to the beginning, and our start position
+           ;; is at the very beginning, we want to test within the added space.
+           ;; Otherwise adjust the start and end for the beginning padding.
+           with start-pos = (if (= 1 start-pos) 1 (+ padding-adjust start-pos))
+           with end-pos = (+ end-pos padding-adjust)
+           do (loop for pos from start-pos to end-pos
+                 do (rust-test-manip-code
+                     (concat padding-beginning unfilled padding-end)
+                     pos
+                     (lambda () 
+                       (let ((fill-column rust-test-fill-column))
+                         (fill-paragraph)))
+                     (concat padding-beginning expected padding-end)))))))
 
 (ert-deftest fill-paragraph-top-level-multi-line-style-doc-comment-second-line ()
   (test-fill-paragraph 
@@ -262,14 +262,14 @@ fn bar() { }" 14 67))
 /// "
    103
    "This is the second really really really really really really long paragraph"
-   "/// This is the first really
+    "/// This is the first really
 /// really really really really
 /// really really long paragraph
 ///
 /// This is the second really
 /// really really really really
 /// really long paragraph"
-   ))
+    ))
 
 (ert-deftest auto-fill-multi-line-prefixless ()
   (test-auto-fill
@@ -295,7 +295,7 @@ very very very long string
 
 (ert-deftest indent-struct-fields-aligned ()
   (test-indent
-   "
+"
 struct Foo { bar: int,
              baz: int }
 
@@ -305,7 +305,7 @@ struct Blah {x:int,
 
 (ert-deftest indent-doc-comments ()
   (test-indent
-   "
+"
 /**
  * This is a doc comment
  *
@@ -411,7 +411,7 @@ fn nexted_fns(a: fn(b:int,
     0
 }
 "
-   ))
+))
 
 (ert-deftest indent-multi-line-expr ()
   (test-indent
@@ -423,206 +423,4 @@ fn foo()
         b();
 }
 "
-   ))
-
-(setq rust-test-motion-string
-      "
-fn fn1(arg: int) -> bool {
-    let x = 5;
-    let y = b();
-    true
-}
-
-fn fn2(arg: int) -> bool {
-    let x = 5;
-    let y = b();
-    true
-}
-
-pub fn fn3(arg: int) -> bool {
-    let x = 5;
-    let y = b();
-    true
-}
-
-struct Foo {
-    x: int
-}
-"
-      rust-test-region-string rust-test-motion-string
-      ;; Symbol -> (line column)
-      rust-test-positions-alist '((start-of-fn1 (2 0))
-                                  (start-of-fn1-middle-of-line (2 15))
-                                  (middle-of-fn1 (3 7))
-                                  (end-of-fn1 (6 0))
-                                  (between-fn1-fn2 (7 0))
-                                  (start-of-fn2 (8 0))
-                                  (middle-of-fn2 (10 4))
-                                  (before-start-of-fn1 (1 0))
-                                  (after-end-of-fn2 (13 0))
-                                  (beginning-of-fn3 (14 0))
-                                  (middle-of-fn3 (16 4))
-                                  (middle-of-struct (21 10))
-                                  (before-start-of-struct (19 0))
-                                  (after-end-of-struct (23 0))))
-
-(defun rust-get-buffer-pos (pos-symbol)
-  "Get buffer position from POS-SYMBOL.
-
-POS-SYMBOL is a symbol found in `rust-test-positions-alist'.
-Convert the line-column information from that list into a buffer position value."
-  (interactive "P")
-  (pcase-let ((`(,line ,column) (cadr (assoc pos-symbol rust-test-positions-alist))))
-    (save-excursion
-      (goto-line line)
-      (move-to-column column)
-      (point))))
-
-;;; TODO: Maybe add an ERT explainer function (something that shows the
-;;; surrounding code of the final point, not just the position).
-(defun rust-test-motion (source-code init-pos final-pos manip-func &optional &rest args)
-  "Test that MANIP-FUNC moves point from INIT-POS to FINAL-POS.
-
-If ARGS are provided, send them to MANIP-FUNC.
-
-INIT-POS, FINAL-POS are position symbols found in `rust-test-positions-alist'."
-  (with-temp-buffer
-    (rust-mode)
-    (insert source-code)
-    (goto-char (rust-get-buffer-pos init-pos))
-    (apply manip-func args)
-    (should (equal (point) (rust-get-buffer-pos final-pos)))))
-
-(defun rust-test-region (source-code init-pos reg-beg reg-end manip-func &optional &rest args)
-  "Test that MANIP-FUNC marks region from REG-BEG to REG-END.
-
-INIT-POS is the initial position of point.
-If ARGS are provided, send them to MANIP-FUNC.
-All positions are position symbols found in `rust-test-positions-alist'."
-  (with-temp-buffer
-    (rust-mode)
-    (insert source-code)
-    (goto-char (rust-get-buffer-pos init-pos))
-    (apply manip-func args)
-    (should (equal (list (region-beginning) (region-end))
-                   (list (rust-get-buffer-pos reg-beg)
-                         (rust-get-buffer-pos reg-end))))))
-
-(ert-deftest rust-beginning-of-defun-from-middle-of-fn ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn1
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-from-end ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'end-of-fn1
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-before-open-brace ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'start-of-fn1-middle-of-line
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-between-fns ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'between-fn1-fn2
-   'start-of-fn1
-   #'beginning-of-defun))
-
-(ert-deftest rust-beginning-of-defun-with-arg ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn2
-   'start-of-fn1
-   #'beginning-of-defun 2))
-
-(ert-deftest rust-beginning-of-defun-with-negative-arg ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn1
-   'beginning-of-fn3
-   #'beginning-of-defun -2))
-
-(ert-deftest rust-beginning-of-defun-pub-fn ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn3
-   'beginning-of-fn3
-   #'beginning-of-defun))
-
-(ert-deftest rust-end-of-defun-from-middle-of-fn ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn1
-   'between-fn1-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-from-beg ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'start-of-fn1
-   'between-fn1-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-before-open-brace ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'start-of-fn1-middle-of-line
-   'between-fn1-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-between-fns ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'between-fn1-fn2
-   'after-end-of-fn2
-   #'end-of-defun))
-
-(ert-deftest rust-end-of-defun-with-arg ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn1
-   'after-end-of-fn2
-   #'end-of-defun 2))
-
-(ert-deftest rust-end-of-defun-with-negative-arg ()
-  (rust-test-motion 
-   rust-test-motion-string
-   'middle-of-fn3
-   'between-fn1-fn2
-   #'end-of-defun -2))
-
-(ert-deftest rust-mark-defun-from-middle-of-fn ()
-  (rust-test-region
-   rust-test-region-string
-   'middle-of-fn2
-   'between-fn1-fn2 'after-end-of-fn2
-   #'mark-defun))
-
-(ert-deftest rust-mark-defun-from-end ()
-  (rust-test-region 
-   rust-test-region-string
-   'end-of-fn1
-   'before-start-of-fn1 'between-fn1-fn2
-   #'mark-defun))
-
-(ert-deftest rust-mark-defun-start-of-defun ()
-  (rust-test-region 
-   rust-test-region-string
-   'start-of-fn2
-   'between-fn1-fn2 'after-end-of-fn2
-   #'mark-defun))
-
-(ert-deftest rust-mark-defun-from-middle-of-struct ()
-  (rust-test-region
-   rust-test-region-string
-   'middle-of-struct
-   'before-start-of-struct 'after-end-of-struct
-   #'mark-defun))
+))