Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Restrict where in the tree platform-specific cfgs may be mentioned #36807

Merged
merged 7 commits into from Oct 3, 2016

Conversation

@brson
Copy link
Contributor

brson commented Sep 28, 2016

With the ports of Rust never ending, it's important that we keep things tidy. The main thing this PR does is introduce a new "pal" (platform abstraction layer) tidy check that limits where platform-specific CFGs may appear.

This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where cfg(unix),
cfg(windows), cfg(target_os) and cfg(target_env) may appear,
the basic objective being to isolate platform-specific code to the
platform-specific std::sys modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

  • core may not have platform-specific code
  • liballoc_system may have platform-specific code
  • liballoc_jemalloc may have platform-specific code
  • libpanic_abort may have platform-specific code
  • libpanic_unwind may have platform-specific code
  • other crates in the std facade may not
  • std may have platform-specific code in the following places
    • sys/unix/
    • sys/windows/
    • os/

There are plenty of exceptions today though, noted in the whitelist.

The end-state, IMO, is for the standard library to be portable by porting only std::sys (possibly extracted to its own crate), an allocator crate, an unwinder crate, and possibly a libc crate (if std depends on it); but that outcome is far off and independent of the utility of enforcing where such code lives today.

cc @rust-lang/libs

@rust-highfive
Copy link
Collaborator

rust-highfive commented Sep 28, 2016

r? @aturon

(rust_highfive has picked a reviewer for you, use r? to override)

@alexcrichton
Copy link
Member

alexcrichton commented Sep 29, 2016

Looks great to me!

// option. This file may not be copied, modified, or distributed
// except according to those terms.

#[cfg(target_os = "windows")]

This comment has been minimized.

Copy link
@alexcrichton

alexcrichton Sep 29, 2016

Member

This can be removed I think

@brson brson force-pushed the brson:pal branch from 6b8065a to c6c89f0 Sep 29, 2016
@brson
Copy link
Contributor Author

brson commented Sep 29, 2016

Updated.

@brson brson force-pushed the brson:pal branch from 4efa10f to 2086608 Sep 29, 2016
@brson
Copy link
Contributor Author

brson commented Sep 29, 2016

@rust-highfive rust-highfive assigned alexcrichton and unassigned aturon Sep 29, 2016
@brson
Copy link
Contributor Author

brson commented Sep 29, 2016

I did some more refactoring, moving the argument handling around. That'll surely bounce a few times on misc platforms...

@alexcrichton
Copy link
Member

alexcrichton commented Sep 29, 2016

@bors: r+

@bors
Copy link
Contributor

bors commented Sep 29, 2016

📌 Commit 2086608 has been approved by alexcrichton

@brson brson force-pushed the brson:pal branch from 2086608 to 54440be Sep 29, 2016
@brson
Copy link
Contributor Author

brson commented Sep 29, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Sep 29, 2016

📌 Commit 54440be has been approved by alexcrichton

@brson brson force-pushed the brson:pal branch from 54440be to 5cf31ba Sep 30, 2016
@brson
Copy link
Contributor Author

brson commented Sep 30, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Sep 30, 2016

📌 Commit 5cf31ba has been approved by alexcrichton

@brson brson force-pushed the brson:pal branch from 5cf31ba to 1472c45 Sep 30, 2016
@brson
Copy link
Contributor Author

brson commented Sep 30, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Sep 30, 2016

📌 Commit 1472c45 has been approved by alexcrichton

@bors
Copy link
Contributor

bors commented Sep 30, 2016

Testing commit 1472c45 with merge dbcc5b1...

bors added a commit that referenced this pull request Sep 30, 2016
Restrict where in the tree platform-specific cfgs may be mentioned

With the ports of Rust never ending, it's important that we keep things tidy. The main thing this PR does is introduce  a new "pal" (platform abstraction layer) tidy check that limits where platform-specific CFGs may appear.

This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where `cfg(unix)`,
`cfg(windows)`, `cfg(target_os)` and `cfg(target_env)` may appear,
the basic objective being to isolate platform-specific code to the
platform-specific `std::sys` modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

- core may not have platform-specific code
- liballoc_system may have platform-specific code
- liballoc_jemalloc may have platform-specific code
- libpanic_abort may have platform-specific code
- libpanic_unwind may have platform-specific code
- other crates in the std facade may not
- std may have platform-specific code in the following places
  - sys/unix/
  - sys/windows/
  - os/

There are plenty of exceptions today though, noted in the whitelist.

The end-state, IMO, is for the standard library to be portable by porting only `std::sys` (possibly extracted to its own crate), an allocator crate, an unwinder crate, and possibly a libc crate (if std depends on it); but that outcome is far off and independent of the utility of enforcing where such code lives today.

cc @rust-lang/libs
@bors
Copy link
Contributor

bors commented Sep 30, 2016

💔 Test failed - auto-win-gnu-32-opt-rustbuild

@brson brson force-pushed the brson:pal branch from 1472c45 to ba9e75e Sep 30, 2016
@brson
Copy link
Contributor Author

brson commented Sep 30, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Sep 30, 2016

📌 Commit ba9e75e has been approved by alexcrichton

@brson brson force-pushed the brson:pal branch from ba9e75e to 57cd2d6 Sep 30, 2016
@brson
Copy link
Contributor Author

brson commented Sep 30, 2016

@bors r=alexcrichton

@brson brson force-pushed the brson:pal branch from b710344 to 1a30e0f Oct 1, 2016
@brson
Copy link
Contributor Author

brson commented Oct 1, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Oct 1, 2016

📌 Commit 1a30e0f has been approved by alexcrichton

@bors
Copy link
Contributor

bors commented Oct 1, 2016

Testing commit 1a30e0f with merge bdded68...

bors added a commit that referenced this pull request Oct 1, 2016
Restrict where in the tree platform-specific cfgs may be mentioned

With the ports of Rust never ending, it's important that we keep things tidy. The main thing this PR does is introduce  a new "pal" (platform abstraction layer) tidy check that limits where platform-specific CFGs may appear.

This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where `cfg(unix)`,
`cfg(windows)`, `cfg(target_os)` and `cfg(target_env)` may appear,
the basic objective being to isolate platform-specific code to the
platform-specific `std::sys` modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

- core may not have platform-specific code
- liballoc_system may have platform-specific code
- liballoc_jemalloc may have platform-specific code
- libpanic_abort may have platform-specific code
- libpanic_unwind may have platform-specific code
- other crates in the std facade may not
- std may have platform-specific code in the following places
  - sys/unix/
  - sys/windows/
  - os/

There are plenty of exceptions today though, noted in the whitelist.

The end-state, IMO, is for the standard library to be portable by porting only `std::sys` (possibly extracted to its own crate), an allocator crate, an unwinder crate, and possibly a libc crate (if std depends on it); but that outcome is far off and independent of the utility of enforcing where such code lives today.

cc @rust-lang/libs
@bors
Copy link
Contributor

bors commented Oct 1, 2016

💔 Test failed - auto-mac-cross-ios-opt

@brson brson force-pushed the brson:pal branch from 1a30e0f to 405c010 Oct 1, 2016
@brson
Copy link
Contributor Author

brson commented Oct 1, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Oct 1, 2016

📌 Commit 405c010 has been approved by alexcrichton

@bors
Copy link
Contributor

bors commented Oct 2, 2016

Testing commit 405c010 with merge d97a08e...

bors added a commit that referenced this pull request Oct 2, 2016
Restrict where in the tree platform-specific cfgs may be mentioned

With the ports of Rust never ending, it's important that we keep things tidy. The main thing this PR does is introduce  a new "pal" (platform abstraction layer) tidy check that limits where platform-specific CFGs may appear.

This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where `cfg(unix)`,
`cfg(windows)`, `cfg(target_os)` and `cfg(target_env)` may appear,
the basic objective being to isolate platform-specific code to the
platform-specific `std::sys` modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

- core may not have platform-specific code
- liballoc_system may have platform-specific code
- liballoc_jemalloc may have platform-specific code
- libpanic_abort may have platform-specific code
- libpanic_unwind may have platform-specific code
- other crates in the std facade may not
- std may have platform-specific code in the following places
  - sys/unix/
  - sys/windows/
  - os/

There are plenty of exceptions today though, noted in the whitelist.

The end-state, IMO, is for the standard library to be portable by porting only `std::sys` (possibly extracted to its own crate), an allocator crate, an unwinder crate, and possibly a libc crate (if std depends on it); but that outcome is far off and independent of the utility of enforcing where such code lives today.

cc @rust-lang/libs
@bors
Copy link
Contributor

bors commented Oct 2, 2016

💔 Test failed - auto-win-msvc-32-opt

@brson brson force-pushed the brson:pal branch from 405c010 to 61afff3 Oct 2, 2016
@brson
Copy link
Contributor Author

brson commented Oct 2, 2016

@bors r=alexcrichton

@bors
Copy link
Contributor

bors commented Oct 2, 2016

📌 Commit 61afff3 has been approved by alexcrichton

@bors
Copy link
Contributor

bors commented Oct 2, 2016

Testing commit 61afff3 with merge f3add2e...

bors added a commit that referenced this pull request Oct 2, 2016
Restrict where in the tree platform-specific cfgs may be mentioned

With the ports of Rust never ending, it's important that we keep things tidy. The main thing this PR does is introduce  a new "pal" (platform abstraction layer) tidy check that limits where platform-specific CFGs may appear.

This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where `cfg(unix)`,
`cfg(windows)`, `cfg(target_os)` and `cfg(target_env)` may appear,
the basic objective being to isolate platform-specific code to the
platform-specific `std::sys` modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

- core may not have platform-specific code
- liballoc_system may have platform-specific code
- liballoc_jemalloc may have platform-specific code
- libpanic_abort may have platform-specific code
- libpanic_unwind may have platform-specific code
- other crates in the std facade may not
- std may have platform-specific code in the following places
  - sys/unix/
  - sys/windows/
  - os/

There are plenty of exceptions today though, noted in the whitelist.

The end-state, IMO, is for the standard library to be portable by porting only `std::sys` (possibly extracted to its own crate), an allocator crate, an unwinder crate, and possibly a libc crate (if std depends on it); but that outcome is far off and independent of the utility of enforcing where such code lives today.

cc @rust-lang/libs
@bors
Copy link
Contributor

bors commented Oct 2, 2016

💔 Test failed - auto-linux-32-opt

brson added 2 commits Sep 22, 2016
This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where `cfg(unix)`,
`cfg(windows)`, `cfg(target_os)` and `cfg(target_env)` may appear,
the basic objective being to isolate platform-specific code to the
platform-specific `std::sys` modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

- core may not have platform-specific code
- liballoc_system may have platform-specific code
- liballoc_jemalloc may have platform-specific code
- libpanic_abort may have platform-specific code
- libpanic_unwind may have platform-specific code
- other crates in the std facade may not
- std may have platform-specific code in the following places
  - sys/unix/
  - sys/windows/
  - os/

There are plenty of exceptions today though, noted in the whitelist.
@brson brson force-pushed the brson:pal branch from 61afff3 to 4d76ac8 Oct 2, 2016
@brson
Copy link
Contributor Author

brson commented Oct 2, 2016

@bors r+

@bors
Copy link
Contributor

bors commented Oct 2, 2016

📌 Commit 4d76ac8 has been approved by brson

@bors
Copy link
Contributor

bors commented Oct 3, 2016

Testing commit 4d76ac8 with merge 144af3e...

bors added a commit that referenced this pull request Oct 3, 2016
Restrict where in the tree platform-specific cfgs may be mentioned

With the ports of Rust never ending, it's important that we keep things tidy. The main thing this PR does is introduce  a new "pal" (platform abstraction layer) tidy check that limits where platform-specific CFGs may appear.

This is intended to maintain existing standards of code organization
in hopes that the standard library will continue to be refactored to
isolate platform-specific bits, making porting easier; where "standard
library" roughly means "all the dependencies of the std and test
crates".

This generally means placing restrictions on where `cfg(unix)`,
`cfg(windows)`, `cfg(target_os)` and `cfg(target_env)` may appear,
the basic objective being to isolate platform-specific code to the
platform-specific `std::sys` modules, and to the allocation,
unwinding, and libc crates.

Following are the basic rules, though there are currently
exceptions:

- core may not have platform-specific code
- liballoc_system may have platform-specific code
- liballoc_jemalloc may have platform-specific code
- libpanic_abort may have platform-specific code
- libpanic_unwind may have platform-specific code
- other crates in the std facade may not
- std may have platform-specific code in the following places
  - sys/unix/
  - sys/windows/
  - os/

There are plenty of exceptions today though, noted in the whitelist.

The end-state, IMO, is for the standard library to be portable by porting only `std::sys` (possibly extracted to its own crate), an allocator crate, an unwinder crate, and possibly a libc crate (if std depends on it); but that outcome is far off and independent of the utility of enforcing where such code lives today.

cc @rust-lang/libs
@bors bors merged commit 4d76ac8 into rust-lang:master Oct 3, 2016
2 checks passed
2 checks passed
continuous-integration/travis-ci/pr The Travis CI build passed
Details
homu Test successful
Details
@bors bors mentioned this pull request Oct 3, 2016
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Linked issues

Successfully merging this pull request may close these issues.

None yet

5 participants
You can’t perform that action at this time.