WithSemantics {

vfs: &'a Vfs,

semantics: &'a Semantics<'a, RootDatabase>,

},

WithoutSemantics {

reason: &'a str,

},

pub ast: SourceFile,

pub text: Arc<str>,

pub errors: Vec<SyntaxError>,

pub semantics_info: Result<FileSemanticInformation<'a>, &'a str>,

pub fn load_workspace(

project: &ProjectManifest,

config: &CargoConfig,

) -> Option<(RootDatabase, Vfs)> {

let progress = |t| (log::trace!("progress: {}", t));

let load_config = LoadCargoConfig {

load_out_dirs_from_check: true,

with_proc_macro_server: ProcMacroServerChoice::Sysroot,

prefill_caches: false,

};

let manifest = project.manifest_path();

match load_workspace_at(manifest.as_ref(), config, &load_config, &progress) {

Ok((db, vfs, _macro_server)) => Some((db, vfs)),

Err(err) => {

log::error!("failed to load workspace for {}: {}", manifest, err);

None

}

}

}

pub fn new(vfs: &'a Vfs, semantics: &'a Semantics<'a, RootDatabase>) -> Self {

RustAnalyzer::WithSemantics { vfs, semantics }

}

pub fn parse(&self, path: &Path) -> ParseResult {

let no_semantics_reason;

match self {

RustAnalyzer::WithSemantics { vfs, semantics } => {

if let Some(file_id) = path_to_file_id(path, vfs) {

if let Ok(input) = std::panic::catch_unwind(|| semantics.db.file_text(file_id))

{

let file_id = EditionedFileId::current_edition(file_id);

let source_file = semantics.parse(file_id);

let errors = semantics

.db

.parse_errors(file_id)

.into_iter()

.flat_map(|x| x.to_vec())

.collect();

return ParseResult {

ast: source_file,

text: input,

errors,

semantics_info: Ok(FileSemanticInformation { file_id, semantics }),

};

}

debug!(

"No text available for file_id '{:?}', falling back to loading file '{}' from disk.",

file_id,

path.to_string_lossy()

);

no_semantics_reason = "no text available for the file in the project";

} else {

no_semantics_reason = "file not found in project";

}

}

RustAnalyzer::WithoutSemantics { reason } => {

no_semantics_reason = reason;

}

}

let mut errors = Vec::new();

let input = match std::fs::read(path) {

Ok(data) => data,

Err(e) => {

errors.push(SyntaxError::new(

format!("Could not read {}: {}", path.to_string_lossy(), e),

TextRange::empty(TextSize::default()),

));

vec![]

}

};

let (input, err) = from_utf8_lossy(&input);

let parse = ra_ap_syntax::ast::SourceFile::parse(&input, Edition::CURRENT);

errors.extend(parse.errors());

errors.extend(err);

ParseResult {

ast: parse.tree(),

text: input.as_ref().into(),

errors,

semantics_info: Err(no_semantics_reason),

}

}

files: &[PathBuf],

) -> anyhow::Result<Vec<ra_ap_project_model::ProjectManifest>> {

let current = std::env::current_dir()?;

let abs_files: Vec<_> = files

.iter()

.map(|path| AbsPathBuf::assert_utf8(current.join(path)))

.collect();

let ret = ra_ap_project_model::ProjectManifest::discover_all(&abs_files);

let iter = || ret.iter().map(|m| format!(" {m}"));

const LOG_LIMIT: usize = 10;

if ret.len() <= LOG_LIMIT {

info!("found manifests:\n{}", iter().join("\n"));

} else {

info!(

"found manifests:\n{}\nand {} more",

iter().take(LOG_LIMIT).join("\n"),

ret.len() - LOG_LIMIT

);

debug!(

"rest of the manifests found:\n{}",

iter().dropping(LOG_LIMIT).join("\n")

);

}

Ok(ret)

let mut iter = v.utf8_chunks();

let (first_valid, first_invalid) = if let Some(chunk) = iter.next() {

let valid = chunk.valid();

let invalid = chunk.invalid();

if invalid.is_empty() {

debug_assert_eq!(valid.len(), v.len());

return (Cow::Borrowed(valid), None);

}

(valid, invalid)

} else {

return (Cow::Borrowed(""), None);

};

const REPLACEMENT: &str = "\u{FFFD}";

let error_start = first_valid.len() as u32;

let error_end = error_start + first_invalid.len() as u32;

let error_range = TextRange::new(TextSize::new(error_start), TextSize::new(error_end));

let error = SyntaxError::new("invalid utf-8 sequence".to_owned(), error_range);

let mut res = String::with_capacity(v.len());

res.push_str(first_valid);

res.push_str(REPLACEMENT);

for chunk in iter {

res.push_str(chunk.valid());

if !chunk.invalid().is_empty() {

res.push_str(REPLACEMENT);

}

}

(Cow::Owned(res), Some(error))

if cfg!(windows) {

dunce::canonicalize(path).ok()

} else {

None

}

// There seems to be some flaky inconsistencies around paths on Windows, where sometimes paths

// are registered in `vfs` without the `//?/` long path prefix. Then it happens that paths with

// that prefix are not found. To work around that, on Windows after failing to find `path` as

// is, we then try to canonicalize it using dunce. Dunce will be able to losslessly convert a

// `//?/` path into its equivalent one in `vfs` without the prefix, if there is one.

iter::once(path.to_path_buf())

.chain(canonicalize_if_on_windows(path))

.filter_map(|p| {

Utf8PathBuf::from_path_buf(p)

.ok()

.and_then(|x| AbsPathBuf::try_from(x).ok())

.map(VfsPath::from)

.and_then(|x| vfs.file_id(&x))

})

.next()