Update to nightly-2019-01-16 #77

DarkKirb · 2019-03-15T16:22:18Z

This pull request changes the std component to be closer to the nightly-2019-01-16 one. It builds and works using the nightly-2019-01-16 compiler. This fixes #75

FenrirWolf · 2019-03-17T22:07:11Z

Nice job! Looks like the only thing keeping this from passing CI is a few missing doc comments. Just add those and I'll bet it'll be good to merge.

FenrirWolf · 2019-03-25T18:14:45Z

ctr-std/src/thread/mod.rs

+    {
+        unsafe { self.spawn_unchecked(f) }
+    }
+    #[unstable(feature = "thread_spawn_unchecked", issue = "55132")]


Doc comment is missing here which prevents compilation from succeeding.

Suggested change

#[unstable(feature = "thread_spawn_unchecked", issue = "55132")]

/// Spawns a new thread without any lifetime restrictions by taking ownership

/// of the `Builder`, and returns an [`io::Result`] to its [`JoinHandle`].

///

/// The spawned thread may outlive the caller (unless the caller thread

/// is the main thread; the whole process is terminated when the main

/// thread finishes). The join handle can be used to block on

/// termination of the child thread, including recovering its panics.

///

/// This method is identical to [`thread::Builder::spawn`][`Builder::spawn`],

/// except for the relaxed lifetime bounds, which render it unsafe.

/// For a more complete documentation see [`thread::spawn`][`spawn`].

///

/// # Errors

///

/// Unlike the [`spawn`] free function, this method yields an

/// [`io::Result`] to capture any failure to create the thread at

/// the OS level.

///

/// # Panics

///

/// Panics if a thread name was set and it contained null bytes.

///

/// # Safety

///

/// The caller has to ensure that no references in the supplied thread closure

/// or its return type can outlive the spawned thread's lifetime. This can be

/// guaranteed in two ways:

///

/// - ensure that [`join`][`JoinHandle::join`] is called before any referenced

/// data is dropped

/// - use only types with `'static` lifetime bounds, i.e., those with no or only

/// `'static` references (both [`thread::Builder::spawn`][`Builder::spawn`]

/// and [`thread::spawn`][`spawn`] enforce this property statically)

///

/// # Examples

///

/// ```

/// #![feature(thread_spawn_unchecked)]

/// use std::thread;

///

/// let builder = thread::Builder::new();

///

/// let x = 1;

/// let thread_x = &x;

///

/// let handler = unsafe {

/// builder.spawn_unchecked(move || {

/// println!("x = {}", *thread_x);

/// }).unwrap()

/// };

///

/// // caller has to ensure `join()` is called, otherwise

/// // it is possible to access freed memory if `x` gets

/// // dropped before the thread closure is executed!

/// handler.join().unwrap();

/// ```

///

/// [`spawn`]: ../../std/thread/fn.spawn.html

/// [`Builder::spawn`]: ../../std/thread/struct.Builder.html#method.spawn

/// [`io::Result`]: ../../std/io/type.Result.html

/// [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html

#[unstable(feature = "thread_spawn_unchecked", issue = "55132")]

FenrirWolf · 2019-03-25T18:17:00Z

ctr-std/src/macros.rs

@@ -220,6 +220,23 @@ macro_rules! eprintln {
    })
 }

+#[stable(feature = "debug", since = "1.69.0")]


Missing doc comment on this macro prevents compilation from succeeding

Suggested change

#[stable(feature = "debug", since = "1.69.0")]

/// A macro for quick and dirty debugging with which you can inspect

/// the value of a given expression. An example:

///

/// ```rust

/// let a = 2;

/// let b = dbg!(a * 2) + 1;

/// // ^-- prints: [src/main.rs:2] a * 2 = 4

/// assert_eq!(b, 5);

/// ```

///

/// The macro works by using the `Debug` implementation of the type of

/// the given expression to print the value to [stderr] along with the

/// source location of the macro invocation as well as the source code

/// of the expression.

///

/// Invoking the macro on an expression moves and takes ownership of it

/// before returning the evaluated expression unchanged. If the type

/// of the expression does not implement `Copy` and you don't want

/// to give up ownership, you can instead borrow with `dbg!(&expr)`

/// for some expression `expr`.

///

/// Note that the macro is intended as a debugging tool and therefore you

/// should avoid having uses of it in version control for longer periods.

/// Use cases involving debug output that should be added to version control

/// may be better served by macros such as `debug!` from the `log` crate.

///

/// # Stability

///

/// The exact output printed by this macro should not be relied upon

/// and is subject to future changes.

///

/// # Panics

///

/// Panics if writing to `io::stderr` fails.

///

/// # Further examples

///

/// With a method call:

///

/// ```rust

/// fn foo(n: usize) {

/// if let Some(_) = dbg!(n.checked_sub(4)) {

/// // ...

/// }

/// }

///

/// foo(3)

/// ```

///

/// This prints to [stderr]:

///

/// ```text,ignore

/// [src/main.rs:4] n.checked_sub(4) = None

/// ```

///

/// Naive factorial implementation:

///

/// ```rust

/// fn factorial(n: u32) -> u32 {

/// if dbg!(n <= 1) {

/// dbg!(1)

/// } else {

/// dbg!(n * factorial(n - 1))

/// }

/// }

///

/// dbg!(factorial(4));

/// ```

///

/// This prints to [stderr]:

///

/// ```text,ignore

/// [src/main.rs:3] n <= 1 = false

/// [src/main.rs:3] n <= 1 = false

/// [src/main.rs:3] n <= 1 = false

/// [src/main.rs:3] n <= 1 = true

/// [src/main.rs:4] 1 = 1

/// [src/main.rs:5] n * factorial(n - 1) = 2

/// [src/main.rs:5] n * factorial(n - 1) = 6

/// [src/main.rs:5] n * factorial(n - 1) = 24

/// [src/main.rs:11] factorial(4) = 24

/// ```

///

/// The `dbg!(..)` macro moves the input:

///

/// ```compile_fail

/// /// A wrapper around `usize` which importantly is not Copyable.

/// #[derive(Debug)]

/// struct NoCopy(usize);

///

/// let a = NoCopy(42);

/// let _ = dbg!(a); // <-- `a` is moved here.

/// let _ = dbg!(a); // <-- `a` is moved again; error!

/// ```

///

/// You can also use `dbg!()` without a value to just print the

/// file and line whenever it's reached.

///

/// [stderr]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)

#[macro_export]

#[stable(feature = "dbg_macro", since = "1.32.0")]

FenrirWolf · 2019-03-25T18:19:26Z

ctr-std/src/macros.rs

+    }
+}
+
+


Missing doc comment prevents compilation from succeeding

Suggested change

/// A macro to await on an async call.

FenrirWolf · 2019-03-25T18:37:50Z

It's also worth mentioning that we already have a separate citro3d-sys repo (albeit an outdated one), but maybe it's worth having everything under this repo anyway instead of separately. Open to opinions about that.

FenrirWolf · 2019-04-11T21:42:44Z

Friendly ping! I'm pretty sure this should be mergeable after the requested changes are made.

Charlotte D added 8 commits March 15, 2019 18:15

Update to nightly-2019-01-16

d36a5cf

switch the travis-ci version to the correct one

f803885

added compiler builtins dep

7ecb621

a

acf25ed

added citro2d and citro3d

423cee8

forgot to set the crate name

f2ab0cd

fix directory names

8d9cf72

remove compiler builtins

a375777

i switched up the libraries

490fcbd

FenrirWolf reviewed Mar 25, 2019

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Update to nightly-2019-01-16 #77

Update to nightly-2019-01-16 #77

DarkKirb commented Mar 15, 2019

FenrirWolf commented Mar 17, 2019

FenrirWolf Mar 25, 2019

FenrirWolf Mar 25, 2019

FenrirWolf Mar 25, 2019

FenrirWolf commented Mar 25, 2019 •

edited

Loading

FenrirWolf commented Apr 11, 2019

-    #[unstable(feature = "thread_spawn_unchecked", issue = "55132")]
+    /// Spawns a new thread without any lifetime restrictions by taking ownership
+    /// of the `Builder`, and returns an [`io::Result`] to its [`JoinHandle`].
+    ///
+    /// The spawned thread may outlive the caller (unless the caller thread
+    /// is the main thread; the whole process is terminated when the main
+    /// thread finishes). The join handle can be used to block on
+    /// termination of the child thread, including recovering its panics.
+    ///
+    /// This method is identical to [`thread::Builder::spawn`][`Builder::spawn`],
+    /// except for the relaxed lifetime bounds, which render it unsafe.
+    /// For a more complete documentation see [`thread::spawn`][`spawn`].
+    ///
+    /// # Errors
+    ///
+    /// Unlike the [`spawn`] free function, this method yields an
+    /// [`io::Result`] to capture any failure to create the thread at
+    /// the OS level.
+    ///
+    /// # Panics
+    ///
+    /// Panics if a thread name was set and it contained null bytes.
+    ///
+    /// # Safety
+    ///
+    /// The caller has to ensure that no references in the supplied thread closure
+    /// or its return type can outlive the spawned thread's lifetime. This can be
+    /// guaranteed in two ways:
+    ///
+    /// - ensure that [`join`][`JoinHandle::join`] is called before any referenced
+    /// data is dropped
+    /// - use only types with `'static` lifetime bounds, i.e., those with no or only
+    /// `'static` references (both [`thread::Builder::spawn`][`Builder::spawn`]
+    /// and [`thread::spawn`][`spawn`] enforce this property statically)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(thread_spawn_unchecked)]
+    /// use std::thread;
+    ///
+    /// let builder = thread::Builder::new();
+    ///
+    /// let x = 1;
+    /// let thread_x = &x;
+    ///
+    /// let handler = unsafe {
+    ///     builder.spawn_unchecked(move || {
+    ///         println!("x = {}", *thread_x);
+    ///     }).unwrap()
+    /// };
+    ///
+    /// // caller has to ensure `join()` is called, otherwise
+    /// // it is possible to access freed memory if `x` gets
+    /// // dropped before the thread closure is executed!
+    /// handler.join().unwrap();
+    /// ```
+    ///
+    /// [`spawn`]: ../../std/thread/fn.spawn.html
+    /// [`Builder::spawn`]: ../../std/thread/struct.Builder.html#method.spawn
+    /// [`io::Result`]: ../../std/io/type.Result.html
+    /// [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html
+    #[unstable(feature = "thread_spawn_unchecked", issue = "55132")]

-#[stable(feature = "debug", since = "1.69.0")]
+/// A macro for quick and dirty debugging with which you can inspect
+/// the value of a given expression. An example:
+///
+/// ```rust
+/// let a = 2;
+/// let b = dbg!(a * 2) + 1;
+/// //      ^-- prints: [src/main.rs:2] a * 2 = 4
+/// assert_eq!(b, 5);
+/// ```
+///
+/// The macro works by using the `Debug` implementation of the type of
+/// the given expression to print the value to [stderr] along with the
+/// source location of the macro invocation as well as the source code
+/// of the expression.
+///
+/// Invoking the macro on an expression moves and takes ownership of it
+/// before returning the evaluated expression unchanged. If the type
+/// of the expression does not implement `Copy` and you don't want
+/// to give up ownership, you can instead borrow with `dbg!(&expr)`
+/// for some expression `expr`.
+///
+/// Note that the macro is intended as a debugging tool and therefore you
+/// should avoid having uses of it in version control for longer periods.
+/// Use cases involving debug output that should be added to version control
+/// may be better served by macros such as `debug!` from the `log` crate.
+///
+/// # Stability
+///
+/// The exact output printed by this macro should not be relied upon
+/// and is subject to future changes.
+///
+/// # Panics
+///
+/// Panics if writing to `io::stderr` fails.
+///
+/// # Further examples
+///
+/// With a method call:
+///
+/// ```rust
+/// fn foo(n: usize) {
+///     if let Some(_) = dbg!(n.checked_sub(4)) {
+///         // ...
+///     }
+/// }
+///
+/// foo(3)
+/// ```
+///
+/// This prints to [stderr]:
+///
+/// ```text,ignore
+/// [src/main.rs:4] n.checked_sub(4) = None
+/// ```
+///
+/// Naive factorial implementation:
+///
+/// ```rust
+/// fn factorial(n: u32) -> u32 {
+///     if dbg!(n <= 1) {
+///         dbg!(1)
+///     } else {
+///         dbg!(n * factorial(n - 1))
+///     }
+/// }
+///
+/// dbg!(factorial(4));
+/// ```
+///
+/// This prints to [stderr]:
+///
+/// ```text,ignore
+/// [src/main.rs:3] n <= 1 = false
+/// [src/main.rs:3] n <= 1 = false
+/// [src/main.rs:3] n <= 1 = false
+/// [src/main.rs:3] n <= 1 = true
+/// [src/main.rs:4] 1 = 1
+/// [src/main.rs:5] n * factorial(n - 1) = 2
+/// [src/main.rs:5] n * factorial(n - 1) = 6
+/// [src/main.rs:5] n * factorial(n - 1) = 24
+/// [src/main.rs:11] factorial(4) = 24
+/// ```
+///
+/// The `dbg!(..)` macro moves the input:
+///
+/// ```compile_fail
+/// /// A wrapper around `usize` which importantly is not Copyable.
+/// #[derive(Debug)]
+/// struct NoCopy(usize);
+///
+/// let a = NoCopy(42);
+/// let _ = dbg!(a); // <-- `a` is moved here.
+/// let _ = dbg!(a); // <-- `a` is moved again; error!
+/// ```
+///
+/// You can also use `dbg!()` without a value to just print the
+/// file and line whenever it's reached.
+///
+/// [stderr]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)
+#[macro_export]
+#[stable(feature = "dbg_macro", since = "1.32.0")]

Update to nightly-2019-01-16 #77

Are you sure you want to change the base?

Update to nightly-2019-01-16 #77

Conversation

DarkKirb commented Mar 15, 2019

FenrirWolf commented Mar 17, 2019

FenrirWolf Mar 25, 2019

Choose a reason for hiding this comment

FenrirWolf Mar 25, 2019

Choose a reason for hiding this comment

FenrirWolf Mar 25, 2019

Choose a reason for hiding this comment

FenrirWolf commented Mar 25, 2019 • edited Loading

FenrirWolf commented Apr 11, 2019

FenrirWolf commented Mar 25, 2019 •

edited

Loading