foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-25 15:29:32 -05:00
Code Issues Packages 1 Wiki Activity

chore: upgrade Rust to 1.56.0 (#12514)

Browse source
This commit is contained in:
Bert Belder 2021-10-25 17:16:16 +02:00
parent b4ab8ef9ea
commit d936a8f3f8
No known key found for this signature in database
GPG key ID: 7A77887B2E2ED461
4 changed files with 134 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
.github/workflows/ci.yml vendored
View file

@ -84,7 +84,7 @@ jobs:
- name: Install Rust
uses: hecrj/setup-rust-action@v1
with:
rust-version: 1.55.0
rust-version: 1.56.0
- name: Install clippy and rustfmt
if: matrix.job == 'lint'
@ -184,15 +184,20 @@ jobs:
sudo ln --force --target /sysroot/etc \
/etc/passwd /etc/shadow /etc/group /etc/gshadow
# Install clang-12 and lld-12 into the chroot environment.
echo "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main" |
sudo dd of=/sysroot/etc/apt/sources.list.d/llvm-toolchain-bionic-12.list
# Install clang-13 and lld-13 into the chroot environment.
echo "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-13 main" |
sudo dd of=/sysroot/etc/apt/sources.list.d/llvm-toolchain-bionic-13.list
curl https://apt.llvm.org/llvm-snapshot.gpg.key |
gpg --dearmor |
sudo dd of=/sysroot/etc/apt/trusted.gpg.d/llvm-snapshot.gpg
sudo chroot /sysroot apt update -y
sudo chroot /sysroot apt install --no-install-recommends -y \
clang-12 lld-12
clang-13 lld-13
# Redirect ld invocations to ld.lld-13 inside the chroot environment.
# Setting the 'LD' environment variable doesn't always work.
sudo chroot /sysroot bash -c \
'ln -f "$(which ld.lld-13)" "$(which ld)"'
# Make rust available inside the chroot environment.
sudo mkdir -p /sysroot/usr/share/rust
@ -221,8 +226,8 @@ jobs:
export CARGO_PROFILE_RELEASE_LTO=false
export RUSTFLAGS="
-C linker-plugin-lto=true
-C linker=clang-12
-C link-arg=-fuse-ld=lld-12
-C linker=clang-13
-C link-arg=-fuse-ld=lld-13
-C link-arg=-Wl,--thinlto-cache-dir=$(pwd)/target/release/lto-cache
-C link-arg=-Wl,--thinlto-cache-policy,cache_size_bytes=700m
-D warnings
@ -231,8 +236,9 @@ jobs:
unset RUSTC_FORCE_INCREMENTAL
# C build configuration.
export CC=clang-12 # Compile c source files with clang.
export CC=clang-13 # Compile c source files with clang.
export CFLAGS=-flto=thin # Tell clang to produce llvm bitcode.
export LD=ld.lld-13 # Use the lld linker.
# Miscellaneous flags.
export CARGO_TERM_COLOR=always
@ -260,7 +266,7 @@ jobs:
~/.cargo/registry/index
~/.cargo/registry/cache
~/.cargo/git/db
key: l-cargo-home-${{ matrix.os }}-${{ hashFiles('Cargo.lock') }}
key: 0-cargo-home-${{ matrix.os }}-${{ hashFiles('Cargo.lock') }}
# In main branch, always creates fresh cache
- name: Cache build output (main)
@ -276,7 +282,7 @@ jobs:
!./target/*/*.zip
!./target/*/*.tar.gz
key: |
l-cargo-target-${{ matrix.os }}-${{ matrix.profile }}-${{ github.sha }}
0-cargo-target-${{ matrix.os }}-${{ matrix.profile }}-${{ github.sha }}
# Restore cache from the latest 'main' branch build.
- name: Cache build output (PR)
@ -292,7 +298,7 @@ jobs:
!./target/*/*.tar.gz
key: never_saved
restore-keys: |
l-cargo-target-${{ matrix.os }}-${{ matrix.profile }}-
0-cargo-target-${{ matrix.os }}-${{ matrix.profile }}-
# Don't save cache after building PRs or branches other than 'main'.
- name: Skip save cache (PR)

5
cli/main.rs
View file

@ -35,6 +35,7 @@ mod tools;
mod tsc;
mod unix_util;
mod version;
mod windows_util;
use crate::file_fetcher::File;
use crate::file_watcher::ResolutionResult;
@ -1364,9 +1365,11 @@ fn unwrap_or_exit<T>(result: Result<T, AnyError>) -> T {
pub fn main() {
setup_exit_process_panic_hook();
unix_util::raise_fd_limit();
windows_util::ensure_stdio_open();
#[cfg(windows)]
colors::enable_ansi(); // For Windows 10
unix_util::raise_fd_limit();
let args: Vec<String> = env::args().collect();
let standalone_res = match standalone::extract_standalone(args.clone()) {

89
cli/windows_util.rs Normal file
View file

@ -0,0 +1,89 @@
// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
/// Ensures that stdin, stdout, and stderr are open and have valid HANDLEs
/// associated with them. There are many places where a `std::fs::File` is
/// constructed from a stdio handle; if the handle is null this causes a panic.
pub fn ensure_stdio_open() {
#[cfg(windows)]
unsafe {
use std::mem::size_of;
use winapi::shared::minwindef::DWORD;
use winapi::shared::minwindef::FALSE;
use winapi::shared::minwindef::TRUE;
use winapi::shared::ntdef::NULL;
use winapi::shared::winerror::ERROR_INVALID_HANDLE;
use winapi::um::errhandlingapi::GetLastError;
use winapi::um::fileapi::CreateFileA;
use winapi::um::fileapi::OPEN_EXISTING;
use winapi::um::handleapi::GetHandleInformation;
use winapi::um::handleapi::INVALID_HANDLE_VALUE;
use winapi::um::minwinbase::SECURITY_ATTRIBUTES;
use winapi::um::processenv::GetStdHandle;
use winapi::um::processenv::SetStdHandle;
use winapi::um::winbase::STD_ERROR_HANDLE;
use winapi::um::winbase::STD_INPUT_HANDLE;
use winapi::um::winbase::STD_OUTPUT_HANDLE;
use winapi::um::winnt::FILE_ATTRIBUTE_NORMAL;
use winapi::um::winnt::FILE_GENERIC_READ;
use winapi::um::winnt::FILE_GENERIC_WRITE;
use winapi::um::winnt::FILE_READ_ATTRIBUTES;
use winapi::um::winnt::FILE_SHARE_READ;
use winapi::um::winnt::FILE_SHARE_WRITE;
for std_handle in [STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE] {
// Check whether stdio handle is open.
let is_valid = match GetStdHandle(std_handle) {
NULL | INVALID_HANDLE_VALUE => false,
handle => {
// The stdio handle is open; check whether its handle is valid.
let mut flags: DWORD = 0;
match GetHandleInformation(handle, &mut flags) {
TRUE => true,
FALSE if GetLastError() == ERROR_INVALID_HANDLE => false,
FALSE => {
panic!("GetHandleInformation failed (error {})", GetLastError());
}
_ => unreachable!(),
}
}
};
if !is_valid {
// Open NUL device.
let desired_access = match std_handle {
STD_INPUT_HANDLE => FILE_GENERIC_READ,
_ => FILE_GENERIC_WRITE | FILE_READ_ATTRIBUTES,
};
let security_attributes = SECURITY_ATTRIBUTES {
nLength: size_of::<SECURITY_ATTRIBUTES>() as DWORD,
lpSecurityDescriptor: NULL,
bInheritHandle: TRUE,
};
let file_handle = CreateFileA(
b"\\\\?\\NUL\0" as *const _ as *mut _,
desired_access,
FILE_SHARE_READ | FILE_SHARE_WRITE,
&security_attributes as *const _ as *mut _,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL,
);
match file_handle {
NULL => unreachable!(),
INVALID_HANDLE_VALUE => {
panic!("Could not open NUL device (error {})", GetLastError());
}
_ => {}
}
// Assign the opened NUL handle to the missing stdio handle.
let success = SetStdHandle(std_handle, file_handle);
match success {
TRUE => {}
FALSE => panic!("SetStdHandle failed (error {})", GetLastError()),
_ => unreachable!(),
}
}
}
}
}

107
runtime/ops/io.rs
View file

@ -20,6 +20,7 @@ use deno_net::io::UnixStreamResource;
use deno_net::ops_tls::TlsStreamResource;
use std::borrow::Cow;
use std::cell::RefCell;
use std::fs::File as StdFile;
use std::io::Read;
use std::io::Write;
use std::rc::Rc;
@ -33,8 +34,19 @@ use tokio::process;
use std::os::unix::io::FromRawFd;
#[cfg(windows)]
use std::os::windows::io::FromRawHandle;
use {
std::os::windows::io::FromRawHandle,
winapi::um::{processenv::GetStdHandle, winbase},
};
#[cfg(unix)]
lazy_static::lazy_static! {
static ref STDIN_HANDLE: StdFile = unsafe { StdFile::from_raw_fd(0) };
static ref STDOUT_HANDLE: StdFile = unsafe { StdFile::from_raw_fd(1) };
static ref STDERR_HANDLE: StdFile = unsafe { StdFile::from_raw_fd(2) };
}
#[cfg(windows)]
lazy_static::lazy_static! {
/// Due to portability issues on Windows handle to stdout is created from raw
/// file descriptor. The caveat of that approach is fact that when this
@ -44,50 +56,14 @@ lazy_static::lazy_static! {
/// resource table is dropped storing reference to that handle, the handle
/// itself won't be closed (so Deno.core.print) will still work.
// TODO(ry) It should be possible to close stdout.
static ref STDIN_HANDLE: Option<std::fs::File> = {
#[cfg(not(windows))]
let stdin = unsafe { Some(std::fs::File::from_raw_fd(0)) };
#[cfg(windows)]
let stdin = unsafe {
let handle = winapi::um::processenv::GetStdHandle(
winapi::um::winbase::STD_INPUT_HANDLE,
);
if handle.is_null() {
return None;
}
Some(std::fs::File::from_raw_handle(handle))
};
stdin
static ref STDIN_HANDLE: StdFile = unsafe {
StdFile::from_raw_handle(GetStdHandle(winbase::STD_INPUT_HANDLE))
};
static ref STDOUT_HANDLE: Option<std::fs::File> = {
#[cfg(not(windows))]
let stdout = unsafe { Some(std::fs::File::from_raw_fd(1)) };
#[cfg(windows)]
let stdout = unsafe {
let handle = winapi::um::processenv::GetStdHandle(
winapi::um::winbase::STD_OUTPUT_HANDLE,
);
if handle.is_null() {
return None;
}
Some(std::fs::File::from_raw_handle(handle))
};
stdout
static ref STDOUT_HANDLE: StdFile = unsafe {
StdFile::from_raw_handle(GetStdHandle(winbase::STD_OUTPUT_HANDLE))
};
static ref STDERR_HANDLE: Option<std::fs::File> = {
#[cfg(not(windows))]
let stderr = unsafe { Some(std::fs::File::from_raw_fd(2)) };
#[cfg(windows)]
let stderr = unsafe {
let handle = winapi::um::processenv::GetStdHandle(
winapi::um::winbase::STD_ERROR_HANDLE,
);
if handle.is_null() {
return None;
}
Some(std::fs::File::from_raw_handle(handle))
};
stderr
static ref STDERR_HANDLE: StdFile = unsafe {
StdFile::from_raw_handle(GetStdHandle(winbase::STD_ERROR_HANDLE))
};
}
@ -107,49 +83,14 @@ pub fn init_stdio() -> Extension {
Extension::builder()
.state(|state| {
let t = &mut state.resource_table;
let (stdin, stdout, stderr) = get_stdio();
if let Some(stream) = stdin {
t.add(stream);
}
if let Some(stream) = stdout {
t.add(stream);
}
if let Some(stream) = stderr {
t.add(stream);
}
t.add(StdFileResource::stdio(&STDIN_HANDLE, "stdin"));
t.add(StdFileResource::stdio(&STDOUT_HANDLE, "stdout"));
t.add(StdFileResource::stdio(&STDERR_HANDLE, "stderr"));
Ok(())
})
.build()
}
pub fn get_stdio() -> (
Option<StdFileResource>,
Option<StdFileResource>,
Option<StdFileResource>,
) {
let stdin = get_stdio_stream(&STDIN_HANDLE, "stdin");
let stdout = get_stdio_stream(&STDOUT_HANDLE, "stdout");
let stderr = get_stdio_stream(&STDERR_HANDLE, "stderr");
(stdin, stdout, stderr)
}
fn get_stdio_stream(
handle: &Option<std::fs::File>,
name: &str,
) -> Option<StdFileResource> {
match handle {
None => None,
Some(file_handle) => match file_handle.try_clone() {
Ok(clone) => {
let tokio_file = tokio::fs::File::from_std(clone);
Some(StdFileResource::stdio(tokio_file, name))
}
Err(_e) => None,
},
}
}
#[cfg(unix)]
use nix::sys::termios;
@ -277,10 +218,10 @@ pub struct StdFileResource {
}
impl StdFileResource {
pub fn stdio(fs_file: tokio::fs::File, name: &str) -> Self {
pub fn stdio(std_file: &StdFile, name: &str) -> Self {
Self {
fs_file: Some(AsyncRefCell::new((
Some(fs_file),
std_file.try_clone().map(tokio::fs::File::from_std).ok(),
Some(FileMetadata::default()),
))),
name: name.to_string(),