use anyhow::Context;

use archive::Archiver;

use log::info;

use ra_ap_hir::Semantics;

use ra_ap_ide_db::line_index::{LineCol, LineIndex};

use ra_ap_project_model::ProjectManifest;

use rust_analyzer::{ParseResult, RustAnalyzer};

use std::{

collections::HashMap,

path::{Path, PathBuf},

};

mod archive;

mod config;

pub mod generated;

mod qltest;

mod rust_analyzer;

mod translate;

pub mod trap;

fn extract(

rust_analyzer: &rust_analyzer::RustAnalyzer,

archiver: &Archiver,

traps: &trap::TrapFileProvider,

file: &std::path::Path,

) {

archiver.archive(file);

let ParseResult {

ast,

text,

errors,

file_id,

} = rust_analyzer.parse(file);

let line_index = LineIndex::new(text.as_ref());

let display_path = file.to_string_lossy();

let mut trap = traps.create("source", file);

let label = trap.emit_file(file);

let mut translator = translate::Translator::new(

trap,

display_path.as_ref(),

label,

line_index,

file_id,

file_id.and(rust_analyzer.semantics()),

);

for err in errors {

translator.emit_parse_error(&ast, &err);

}

let no_location = (LineCol { line: 0, col: 0 }, LineCol { line: 0, col: 0 });

if translator.semantics.is_none() {

translator.emit_diagnostic(

trap::DiagnosticSeverity::Warning,

"semantics".to_owned(),

"semantic analyzer unavailable".to_owned(),

"semantic analyzer unavailable: macro expansion, call graph, and type inference will be skipped.".to_owned(),

no_location,

);

}

translator.emit_source_file(ast);

translator.trap.commit().unwrap_or_else(|err| {

log::error!(

"Failed to write trap file for: {}: {}",

display_path,

err.to_string()

)

});

}

fn main() -> anyhow::Result<()> {

let mut cfg = config::Config::extract().context("failed to load configuration")?;

stderrlog::new()

.module(module_path!())

.verbosity(2 + cfg.verbose as usize)

.init()?;

if cfg.qltest {

qltest::prepare(&mut cfg)?;

}

info!("{cfg:#?}\n");

let traps = trap::TrapFileProvider::new(&cfg).context("failed to set up trap files")?;

let archiver = archive::Archiver {

root: cfg.source_archive_dir.clone(),

};

let files: Vec<PathBuf> = cfg

.inputs

.iter()

.map(|file| {

let file = std::path::absolute(file).unwrap_or(file.to_path_buf());

std::fs::canonicalize(&file).unwrap_or(file)

})

.collect();

let manifests = rust_analyzer::find_project_manifests(&files)?;

let mut map: HashMap<&Path, (&ProjectManifest, Vec<&Path>)> = manifests

.iter()

.map(|x| (x.manifest_path().parent().as_ref(), (x, Vec::new())))

.collect();

let mut other_files = Vec::new();

'outer: for file in &files {

let mut p = file.as_path();

while let Some(parent) = p.parent() {

p = parent;

if let Some((_, files)) = map.get_mut(parent) {

files.push(file);

continue 'outer;

}

}

other_files.push(file);

}

for (manifest, files) in map.values() {

if files.is_empty() {

break;

}

if let Some((ref db, ref vfs)) = RustAnalyzer::load_workspace(manifest, &cfg.scratch_dir) {

let semantics = Semantics::new(db);

let rust_analyzer = RustAnalyzer::new(vfs, semantics);

for file in files {

extract(&rust_analyzer, &archiver, &traps, file);

}

} else {

for file in files {

extract(&RustAnalyzer::WithoutSemantics, &archiver, &traps, file);

}

}

}

for file in other_files {

extract(&RustAnalyzer::WithoutSemantics, &archiver, &traps, file);

}

Ok(())

}