squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Merge #5473

Browse source 
5473: Changes to rust-project.json r=matklad a=matklad



Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>
This commit is contained in:
bors[bot] 2020-07-23 13:58:45 +00:00 committed by GitHub
parent 83f364523f b68ef1231d
commit 7bada8a76d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 118 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crates/ra_db/src/fixture.rs
View file

@ -222,7 +222,7 @@ impl From<Fixture> for FileMeta {
.edition
.as_ref()
.map_or(Edition::Edition2018, |v| Edition::from_str(&v).unwrap()),
env: Env::from(f.env.iter()),
env: f.env.into_iter().collect(),
}
}
}

17
crates/ra_db/src/input.rs
View file

@ -6,7 +6,7 @@
//! actual IO. See `vfs` and `project_model` in the `rust-analyzer` crate for how
//! actual IO is done and lowered to input.
use std::{fmt, ops, str::FromStr, sync::Arc};
use std::{fmt, iter::FromIterator, ops, str::FromStr, sync::Arc};
use ra_cfg::CfgOptions;
use ra_syntax::SmolStr;
@ -298,18 +298,9 @@ impl fmt::Display for Edition {
}
}
impl<'a, T> From<T> for Env
where
T: Iterator<Item = (&'a String, &'a String)>,
{
fn from(iter: T) -> Self {
let mut result = Self::default();
for (k, v) in iter {
result.entries.insert(k.to_owned(), v.to_owned());
}
result
impl FromIterator<(String, String)> for Env {
fn from_iter<T: IntoIterator<Item = (String, String)>>(iter: T) -> Self {
Env { entries: FromIterator::from_iter(iter) }
}
}

4
crates/ra_ide/src/mock_analysis.rs
View file

@ -2,7 +2,7 @@
use std::sync::Arc;
use ra_cfg::CfgOptions;
use ra_db::{CrateName, Env, FileSet, SourceRoot, VfsPath};
use ra_db::{CrateName, FileSet, SourceRoot, VfsPath};
use test_utils::{
extract_annotations, extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER,
};
@ -110,7 +110,7 @@ impl MockAnalysis {
data.edition.and_then(|it| it.parse().ok()).unwrap_or(Edition::Edition2018);
let file_id = FileId(i as u32 + 1);
let env = Env::from(data.env.iter());
let env = data.env.into_iter().collect();
if path == "/lib.rs" || path == "/main.rs" {
root_crate = Some(crate_graph.add_crate_root(
file_id,

87
crates/ra_project_model/src/lib.rs
View file

@ -7,7 +7,6 @@ mod sysroot;
use std::{
fs::{self, read_dir, ReadDir},
io,
path::Path,
process::{Command, Output},
};
@ -35,30 +34,12 @@ pub enum ProjectWorkspace {
/// `PackageRoot` describes a package root folder.
/// Which may be an external dependency, or a member of
/// the current workspace.
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct PackageRoot {
/// Path to the root folder
path: AbsPathBuf,
/// Is a member of the current workspace
is_member: bool,
out_dir: Option<AbsPathBuf>,
}
impl PackageRoot {
pub fn new_member(path: AbsPathBuf) -> PackageRoot {
Self { path, is_member: true, out_dir: None }
}
pub fn new_non_member(path: AbsPathBuf) -> PackageRoot {
Self { path, is_member: false, out_dir: None }
}
pub fn path(&self) -> &AbsPath {
&self.path
}
pub fn out_dir(&self) -> Option<&AbsPath> {
self.out_dir.as_deref()
}
pub fn is_member(&self) -> bool {
self.is_member
}
pub is_member: bool,
pub include: Vec<AbsPathBuf>,
pub exclude: Vec<AbsPathBuf>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
@ -195,18 +176,40 @@ impl ProjectWorkspace {
/// the root is a member of the current workspace
pub fn to_roots(&self) -> Vec<PackageRoot> {
match self {
ProjectWorkspace::Json { project } => {
project.roots.iter().map(|r| PackageRoot::new_member(r.path.clone())).collect()
}
ProjectWorkspace::Json { project } => project
.crates
.iter()
.map(|krate| PackageRoot {
is_member: krate.is_workspace_member,
include: krate.include.clone(),
exclude: krate.exclude.clone(),
})
.collect::<FxHashSet<_>>()
.into_iter()
.collect::<Vec<_>>(),
ProjectWorkspace::Cargo { cargo, sysroot } => cargo
.packages()
.map(|pkg| PackageRoot {
path: cargo[pkg].root().to_path_buf(),
is_member: cargo[pkg].is_member,
out_dir: cargo[pkg].out_dir.clone(),
.map(|pkg| {
let is_member = cargo[pkg].is_member;
let pkg_root = cargo[pkg].root().to_path_buf();
let mut include = vec![pkg_root.clone()];
include.extend(cargo[pkg].out_dir.clone());
let mut exclude = vec![pkg_root.join(".git")];
if is_member {
exclude.push(pkg_root.join("target"));
} else {
exclude.push(pkg_root.join("tests"));
exclude.push(pkg_root.join("examples"));
exclude.push(pkg_root.join("benches"));
}
PackageRoot { is_member, include, exclude }
})
.chain(sysroot.crates().map(|krate| {
PackageRoot::new_non_member(sysroot[krate].root_dir().to_path_buf())
.chain(sysroot.crates().map(|krate| PackageRoot {
is_member: false,
include: vec![sysroot[krate].root_dir().to_path_buf()],
exclude: Vec::new(),
}))
.collect(),
}
@ -255,13 +258,7 @@ impl ProjectWorkspace {
let file_path = &krate.root_module;
let file_id = load(&file_path)?;
let mut env = Env::default();
if let Some(out_dir) = &krate.out_dir {
// NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
env.set("OUT_DIR", out_dir);
}
}
let env = krate.env.clone().into_iter().collect();
let proc_macro = krate
.proc_macro_dylib_path
.clone()
@ -503,18 +500,6 @@ impl ProjectWorkspace {
}
crate_graph
}
pub fn workspace_root_for(&self, path: &Path) -> Option<&AbsPath> {
match self {
ProjectWorkspace::Cargo { cargo, .. } => {
Some(cargo.workspace_root()).filter(|root| path.starts_with(root))
}
ProjectWorkspace::Json { project: ProjectJson { roots, .. }, .. } => roots
.iter()
.find(|root| path.starts_with(&root.path))
.map(|root| root.path.as_path()),
}
}
}
fn get_rustc_cfg_options(target: Option<&str>) -> CfgOptions {

43
crates/ra_project_model/src/project_json.rs
View file

@ -5,24 +5,16 @@ use std::path::PathBuf;
use paths::{AbsPath, AbsPathBuf};
use ra_cfg::CfgOptions;
use ra_db::{CrateId, CrateName, Dependency, Edition};
use rustc_hash::FxHashSet;
use rustc_hash::{FxHashMap, FxHashSet};
use serde::{de, Deserialize};
use stdx::split_delim;
/// Roots and crates that compose this Rust project.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ProjectJson {
pub(crate) roots: Vec<Root>,
pub(crate) crates: Vec<Crate>,
}
/// A root points to the directory which contains Rust crates. rust-analyzer watches all files in
/// all roots. Roots might be nested.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Root {
pub(crate) path: AbsPathBuf,
}
/// A crate points to the root module of a crate and lists the dependencies of the crate. This is
/// useful in creating the crate graph.
#[derive(Clone, Debug, Eq, PartialEq)]
@ -32,15 +24,16 @@ pub struct Crate {
pub(crate) deps: Vec<Dependency>,
pub(crate) cfg: CfgOptions,
pub(crate) target: Option<String>,
pub(crate) out_dir: Option<AbsPathBuf>,
pub(crate) env: FxHashMap<String, String>,
pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>,
pub(crate) is_workspace_member: bool,
pub(crate) include: Vec<AbsPathBuf>,
pub(crate) exclude: Vec<AbsPathBuf>,
}
impl ProjectJson {
pub fn new(base: &AbsPath, data: ProjectJsonData) -> ProjectJson {
ProjectJson {
roots: data.roots.into_iter().map(|path| Root { path: base.join(path) }).collect(),
crates: data
.crates
.into_iter()
@ -50,8 +43,19 @@ impl ProjectJson {
&& !crate_data.root_module.starts_with("..")
|| crate_data.root_module.starts_with(base)
});
let root_module = base.join(crate_data.root_module);
let (include, exclude) = match crate_data.source {
Some(src) => {
let absolutize = |dirs: Vec<PathBuf>| {
dirs.into_iter().map(|it| base.join(it)).collect::<Vec<_>>()
};
(absolutize(src.include_dirs), absolutize(src.exclude_dirs))
}
None => (vec![root_module.parent().unwrap().to_path_buf()], Vec::new()),
};
Crate {
root_module: base.join(crate_data.root_module),
root_module,
edition: crate_data.edition.into(),
deps: crate_data
.deps
@ -74,11 +78,13 @@ impl ProjectJson {
cfg
},
target: crate_data.target,
out_dir: crate_data.out_dir.map(|it| base.join(it)),
env: crate_data.env,
proc_macro_dylib_path: crate_data
.proc_macro_dylib_path
.map(|it| base.join(it)),
is_workspace_member,
include,
exclude,
}
})
.collect::<Vec<_>>(),
@ -88,7 +94,6 @@ impl ProjectJson {
#[derive(Deserialize)]
pub struct ProjectJsonData {
roots: Vec<PathBuf>,
crates: Vec<CrateData>,
}
@ -100,9 +105,11 @@ struct CrateData {
#[serde(default)]
cfg: FxHashSet<String>,
target: Option<String>,
out_dir: Option<PathBuf>,
#[serde(default)]
env: FxHashMap<String, String>,
proc_macro_dylib_path: Option<PathBuf>,
is_workspace_member: Option<bool>,
source: Option<CrateSource>,
}
#[derive(Deserialize)]
@ -132,6 +139,12 @@ struct DepData {
name: CrateName,
}
#[derive(Deserialize)]
struct CrateSource {
include_dirs: Vec<PathBuf>,
exclude_dirs: Vec<PathBuf>,
}
fn deserialize_crate_name<'de, D>(de: D) -> Result<CrateName, D::Error>
where
D: de::Deserializer<'de>,

42
crates/rust-analyzer/src/reload.rs
View file

@ -5,7 +5,7 @@ use flycheck::FlycheckHandle;
use ra_db::{CrateGraph, SourceRoot, VfsPath};
use ra_ide::AnalysisChange;
use ra_prof::profile;
use ra_project_model::{PackageRoot, ProcMacroClient, ProjectWorkspace};
use ra_project_model::{ProcMacroClient, ProjectWorkspace};
use vfs::{file_set::FileSetConfig, AbsPath, AbsPathBuf, ChangeKind};
use crate::{
@ -149,8 +149,10 @@ impl GlobalState {
watchers: workspaces
.iter()
.flat_map(ProjectWorkspace::to_roots)
.filter(PackageRoot::is_member)
.map(|root| format!("{}/**/*.rs", root.path().display()))
.filter(|it| it.is_member)
.flat_map(|root| {
root.include.into_iter().map(|it| format!("{}/**/*.rs", it.display()))
})
.map(|glob_pattern| lsp_types::FileSystemWatcher { glob_pattern, kind: None })
.collect(),
};
@ -261,31 +263,23 @@ impl ProjectFolders {
let mut local_filesets = vec![];
for root in workspaces.iter().flat_map(|it| it.to_roots()) {
let path = root.path().to_owned();
let file_set_roots: Vec<VfsPath> =
root.include.iter().cloned().map(VfsPath::from).collect();
let mut file_set_roots: Vec<VfsPath> = vec![];
let entry = if root.is_member() {
vfs::loader::Entry::local_cargo_package(path.to_path_buf())
} else {
vfs::loader::Entry::cargo_package_dependency(path.to_path_buf())
let entry = {
let mut dirs = vfs::loader::Directories::default();
dirs.extensions.push("rs".into());
dirs.include.extend(root.include);
dirs.exclude.extend(root.exclude);
vfs::loader::Entry::Directories(dirs)
};
if root.is_member {
res.watch.push(res.load.len());
}
res.load.push(entry);
if root.is_member() {
res.watch.push(res.load.len() - 1);
}
if let Some(out_dir) = root.out_dir() {
let out_dir = out_dir.to_path_buf();
res.load.push(vfs::loader::Entry::rs_files_recursively(out_dir.clone()));
if root.is_member() {
res.watch.push(res.load.len() - 1);
}
file_set_roots.push(out_dir.into());
}
file_set_roots.push(path.to_path_buf().into());
if root.is_member() {
if root.is_member {
local_filesets.push(fsc.len());
}
fsc.add_file_set(file_set_roots)

2
crates/vfs/src/loader.rs
View file

@ -17,7 +17,7 @@ pub enum Entry {
/// * it is not under `exclude` path
///
/// If many include/exclude paths match, the longest one wins.
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Default)]
pub struct Directories {
pub extensions: Vec<String>,
pub include: Vec<AbsPathBuf>,

33
docs/user/manual.adoc
View file

@ -273,9 +273,6 @@ However, if you use some other build system, you'll have to describe the structu
[source,TypeScript]
----
interface JsonProject {
/// The set of paths containing the crates for this project.
/// Any `Crate` must be nested inside some `root`.
roots: string[];
/// The set of crates comprising the current project.
/// Must include all transitive dependencies as well as sysroot crate (libstd, libcore and such).
crates: Crate[];
@ -288,11 +285,37 @@ interface Crate {
edition: "2015" | "2018";
/// Dependencies
deps: Dep[];
/// Should this crate be treated as a member of current "workspace".
///
/// By default, inferred from the `root_module` (members are the crates which reside
/// inside the directory opened in the editor).
///
/// Set this to `false` for things like standard library and 3rd party crates to
/// enable performance optimizations (rust-analyzer assumes that non-member crates
/// don't change).
is_workspace_member?: boolean;
/// Optionally specify the (super)set of `.rs` files comprising this crate.
///
/// By default, rust-analyzer assumes that only files under `root_module.parent` can belong to a crate.
/// `include_dirs` are included recursively, unless a subdirectory is in `exclude_dirs`.
///
/// Different crates can share the same `source`.
/// If two crates share an `.rs` file in common, they *must* have the same `source`.
/// rust-analyzer assumes that files from one source can't refer to files in another source.
source?: {
include_dirs: string[],
exclude_dirs: string[],
},
/// The set of cfgs activated for a given crate, like `["unix", "feature=foo", "feature=bar"]`.
cfg: string[];
/// Target triple for this Crate.
///
/// Used when running `rustc --print cfg` to get target-specific cfgs.
target?: string;
/// Environment variables, used for the `env!` macro
env: : { [key: string]: string; },
/// value of the OUT_DIR env variable.
out_dir?: string;
/// For proc-macro crates, path to compiles proc-macro (.so file).
proc_macro_dylib_path?: string;
}