use filetime::FileTime;

use jwalk::WalkDirGeneric;

use lib_ruby_parser::source::DecodedInput;

use lib_ruby_parser::{nodes::*, Loc, Node, Parser, ParserOptions};

use log::info;

use phf::phf_map;

use regex::Regex;

use serde_json::json;

use std::collections::{HashMap, HashSet};

use std::fs;

use std::process::Command;

use std::str;

use tantivy::collector::TopDocs;

use tantivy::query::{BooleanQuery, BoostQuery, Occur, Query, RegexQuery, TermQuery};

use tantivy::{schema::*, ReloadPolicy, Document};

use tantivy::{Index, IndexWriter};

use tower_lsp::lsp_types::InitializeParams;

use tower_lsp::lsp_types::{

DocumentHighlight, DocumentHighlightKind, Location, Position, Range, SymbolInformation,

SymbolKind, TextDocumentPositionParams, TextEdit, Url, WorkspaceEdit,

};

use tower_lsp::Client;

static USAGE_TYPE_RESTRICTIONS: phf::Map<&'static str, &[&str]> = phf_map! {

"Alias" => &[

"Alias", "Def", "Defs",

"CSend", "Send", "Super", "ZSuper",

],

"Const" => &[

"Casgn", "Class", "Module",

"Const"

],

"CSend" => &[

"Alias", "Def", "Defs",

"CSend", "Send", "Super", "ZSuper",

],

"Cvar" => &[

"Cvasgn",

"Cvar"

],

"Gvar" => &[

"Gvasgn",

"Gvar"

],

"Ivar" => &[

"Ivasgn",

"Ivar"

],

"Lvar" => &[

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg",

"Lvar"

],

"Send" => &[

"Alias", "Def", "Defs",

"CSend", "Send", "Super", "ZSuper",

],

"Super" => &[

"Alias", "Def", "Defs",

"CSend", "Send", "Super", "ZSuper",

],

"ZSuper" => &[

"Alias", "Def", "Defs",

"CSend", "Send", "Super", "ZSuper",

],

};

static ASSIGNMENT_TYPE_RESTRICTIONS: phf::Map<&'static str, &[&str]> = phf_map! {

"Alias" => &[

"Alias", "CSend", "Send", "Super", "ZSuper",

"Def", "Defs"

],

"Arg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Casgn" => &[

"Const",

"Casgn", "Class", "Module"

],

"Class" => &[

"Const",

"Casgn", "Class", "Module"

],

"Cvasgn" => &[

"Cvar",

"Cvasgn"

],

"Def" => &[

"Alias", "CSend", "Send", "Super", "ZSuper",

"Def"

],

"Defs" => &[

"Alias", "CSend", "Send", "Super", "ZSuper",

"Defs"

],

"Gvasgn" => &[

"Gvar",

"Gvasgn"

],

"Ivasgn" => &[

"Ivar",

"Ivasgn"

],

"Kwarg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Kwoptarg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Kwrestarg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Lvasgn" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"MatchVar" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Module" => &[

"Const",

"Casgn", "Class", "Module"

],

"Optarg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Restarg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

"Shadowarg" => &[

"Lvar",

"Arg", "Kwarg", "Kwoptarg", "Kwrestarg", "Lvasgn", "MatchVar", "Optarg", "Restarg", "Shadowarg"

],

};

#[derive(Clone)]

pub struct IndexableDir {

path: String,

interface_only: bool,

}

pub struct Persistence {

schema: Schema,

schema_fields: SchemaFields,

index: Option<Index>,

workspace_path: String,

last_reindex_time: i64,

indexed_file_paths: HashSet<String>,

process_id: Option<u32>,

no_workspace: bool,

gems_indexed: bool,

include_dirs_indexed: bool,

index_interface_only: bool,

class_scope: Vec<String>,

include_dirs: Vec<IndexableDir>,

pub report_diagnostics: bool,

}

struct SchemaFields {

file_path_id: Field,

file_path: Field,

category_field: Field,

fuzzy_ruby_scope_field: Field,

class_scope_field: Field,

name_field: Field,

node_type_field: Field,

line_field: Field,

start_column_field: Field,

end_column_field: Field,

columns_field: Field,

user_space_field: Field,

}

#[derive(Debug)]

struct FuzzyNode<'a> {

category: &'a str,

fuzzy_ruby_scope: Vec<String>,

class_scope: Vec<String>,

name: String,

node_type: &'a str,

line: usize,

start_column: usize,

end_column: usize,

}

impl Persistence {

pub fn new() -> tantivy::Result<Persistence> {

let mut schema_builder = Schema::builder();

let schema_fields = SchemaFields {

file_path_id: schema_builder.add_text_field(

"file_path_id",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

file_path: schema_builder.add_text_field(

"file_path",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

category_field: schema_builder.add_text_field(

"category",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

fuzzy_ruby_scope_field: schema_builder.add_text_field(

"fuzzy_ruby_scope",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

class_scope_field: schema_builder.add_text_field(

"class_scope",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

name_field: schema_builder.add_text_field(

"name",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

node_type_field: schema_builder.add_text_field(

"node_type",

TextOptions::default()

.set_indexing_options(

TextFieldIndexing::default()

.set_tokenizer("raw")

.set_index_option(IndexRecordOption::Basic),

)

.set_stored(),

),

line_field: schema_builder.add_u64_field("line", INDEXED | STORED),

start_column_field: schema_builder.add_u64_field("start_column", INDEXED | STORED),

end_column_field: schema_builder.add_u64_field("end_column", INDEXED | STORED),

columns_field: schema_builder.add_u64_field("columns", INDEXED | STORED),

user_space_field: schema_builder.add_bool_field("user_space", INDEXED | STORED),

};

let schema = schema_builder.build();

let index = None;

let workspace_path = "unset".to_string();

let last_reindex_time = FileTime::from_unix_time(0, 0).seconds();

let indexed_file_paths = HashSet::new();

let process_id: Option<u32> = None;

let no_workspace = false;

let gems_indexed = false;

let index_interface_only = false;

let class_scope = vec![];

let report_diagnostics = true;

let include_dirs = Vec::new();

let include_dirs_indexed = false;

Ok(Self {

schema,

schema_fields,

index,

workspace_path,

last_reindex_time,

indexed_file_paths,

process_id,

no_workspace,

gems_indexed,

index_interface_only,

class_scope,

report_diagnostics,

include_dirs,

include_dirs_indexed,

})

}

pub fn initialize(&mut self, params: &InitializeParams) {

let uri = params.root_uri.as_ref().unwrap_or_else(|| {

info!("root_uri wasn't given to initialize, exiting.");

quit::with_code(1);

});

self.workspace_path = uri.path().to_string();

let default_user_config = json!({});

let default_allocation_type = json!("ram");

let user_config = &params

.initialization_options

.as_ref()

.unwrap_or(&default_user_config)

.as_object()

.unwrap();

let allocation_type = user_config

.get("allocationType")

.unwrap_or(&default_allocation_type)

.as_str()

.unwrap();

self.index = match allocation_type {

"ram" => Some(Index::create_in_ram(self.schema.clone())),

"tempdir" => Some(Index::create_from_tempdir(self.schema.clone()).unwrap()),

_ => {

info!("Unknown allocation_type, defaulting to tempdir");

Some(Index::create_from_tempdir(self.schema.clone()).unwrap())

}

};

if let Some(included_dirs) = user_config.get("includeDirs") {

if let Some(dirs) = included_dirs.as_array() {

let dirs = dirs

.iter()

.map(|v| {

// v.as_str().unwrap().to_string()

let dir_params = v.as_object().unwrap();

let dir_path = dir_params.get("path").unwrap().as_str().unwrap();

let interface_only = {

let param = dir_params.get("interface_only");

match param {

Some(val) => val.as_bool().unwrap(),

None => true,

}

};

let dir_path = dir_path.to_string();

let absolute_dir_path = if dir_path.starts_with("/") {

dir_path

} else {

format!("{}/{}", &self.workspace_path, dir_path)

};

IndexableDir {

path: absolute_dir_path,

interface_only,

}

})

.collect();

self.include_dirs = dirs;

};

}

let default_index_gems = json!(true);

let skip_indexing_gems = !user_config

.get("indexGems")

.unwrap_or(&default_index_gems)

.as_bool()

.unwrap();

if skip_indexing_gems {

self.gems_indexed = true;

}

let default_report_diagnostics = json!(true);

let report_diagnostics = user_config

.get("reportDiagnostics")

.unwrap_or(&default_report_diagnostics)

.as_bool()

.unwrap();

if !report_diagnostics {

self.report_diagnostics = false;

}

}

pub fn reindex_modified_files(&mut self) -> tantivy::Result<()> {

let start_time = FileTime::from_unix_time(FileTime::now().unix_seconds(), 0).seconds() - 1;

let last_reindex_time = self.last_reindex_time.clone();

let walk_dir = WalkDirGeneric::<(usize, bool)>::new(&self.workspace_path).process_read_dir(

move |_depth, _path, _read_dir_state, children| {

children.retain(|dir_entry_result| {

dir_entry_result

.as_ref()

.map(|dir_entry| {

if let Some(file_name) = dir_entry.file_name.to_str() {

let ruby_file = file_name.ends_with(".rb");

dir_entry.file_type.is_dir() || ruby_file

} else {

false

}

})

.unwrap_or(false)

});

children.iter_mut().for_each(|dir_entry_result| {

if let Ok(dir_entry) = dir_entry_result {

if let Some(file_name) = dir_entry.file_name.to_str() {

if file_name.contains("node_modules")

|| file_name.contains("tmp")

|| file_name.contains(".git")

{

dir_entry.read_children_path = None;

}

}

}

});

},

);

let mut new_indexable_file_paths = HashSet::new();

let mut indexed_file_paths = HashSet::new();

for entry in walk_dir {

let path = entry.unwrap().path();

let path = path.to_str().unwrap();

let ruby_file = path.ends_with(".rb");

if ruby_file {

indexed_file_paths.insert(path.to_string());

self.indexed_file_paths.remove(path);

let metadata = fs::metadata(path).unwrap();

let mtime = FileTime::from_last_modification_time(&metadata);

let recently_modified = mtime.seconds() >= last_reindex_time;

if recently_modified {

new_indexable_file_paths.insert(path.to_string());

}

}

}

if let Some(index) = &self.index {

let files_added = new_indexable_file_paths.len() > 0;

let files_deleted = self.indexed_file_paths.len() > 0;

if files_added || files_deleted {

let mut index_writer = index.writer(256_000_000).unwrap();

for path in &self.indexed_file_paths {

let relative_path = path.replace(&self.workspace_path, "");

let file_path_id = blake3::hash(&relative_path.as_bytes());

let path_term = Term::from_field_text(

self.schema_fields.file_path_id,

&file_path_id.to_string(),

);

index_writer.delete_term(path_term);

}

for path in &new_indexable_file_paths {

let text = fs::read_to_string(&path).unwrap();

let uri = Url::from_file_path(&path).unwrap();

let relative_path = uri.path().replace(&self.workspace_path, "");

self.reindex_modified_file_without_commit(

&text,

relative_path,

&index_writer,

true,

);

}

index_writer.commit().unwrap();

info!("Indexing workspace complete!");

} else {

info!("No file changes, skipping periodic reindexing.")

}

}

self.last_reindex_time = start_time;

self.indexed_file_paths = indexed_file_paths;

Ok(())

}

pub fn index_included_dirs_once(&mut self) -> tantivy::Result<()> {

if self.include_dirs_indexed {

return Ok(());

}

self.index_interface_only = true;

if self.include_dirs.len() > 0 {

let index = match &self.index {

Some(index) => index,

None => {

info!("missing index");

quit::with_code(1);

}

};

let mut index_writer = index.writer(256_000_000).unwrap();

for indexable_dir in self.include_dirs.clone() {

let walk_dir = WalkDirGeneric::<(usize, bool)>::new(indexable_dir.path.clone())

.process_read_dir(move |_depth, _path, _read_dir_state, children| {

children.retain(|dir_entry_result| {

dir_entry_result

.as_ref()

.map(|dir_entry| {

if let Some(file_name) = dir_entry.file_name.to_str() {

let ruby_file = file_name.ends_with(".rb");

dir_entry.file_type.is_dir() || ruby_file

} else {

false

}

})

.unwrap_or(false)

});

children.iter_mut().for_each(|dir_entry_result| {

if let Ok(dir_entry) = dir_entry_result {

if let Some(file_name) = dir_entry.file_name.to_str() {

if file_name.contains("node_modules")

|| file_name.contains("vendor")

|| file_name.contains("tmp")

|| file_name.contains(".git")

{

dir_entry.read_children_path = None;

}

}

}

});

});

let mut indexable_file_paths = Vec::new();

for entry in walk_dir {

let path = entry.unwrap().path();

let path = path.to_str().unwrap();

let ruby_file = path.ends_with(".rb");

if ruby_file {

indexable_file_paths.push(path.to_string());

}

}

self.index_interface_only = indexable_dir.interface_only;

for path in &indexable_file_paths {

if let Ok(text) = fs::read_to_string(&path) {

let uri = Url::from_file_path(&path).unwrap();

let relative_path = uri.path().replace(&self.workspace_path, "");

self.reindex_modified_file_without_commit(

&text,

relative_path,

&index_writer,

false,

);

}

}

}

index_writer.commit().unwrap();

}

self.include_dirs_indexed = true;

self.index_interface_only = false;

Ok(())

}

pub fn index_gems_once(&mut self) -> tantivy::Result<()> {

if self.gems_indexed {

return Ok(());

}

self.index_interface_only = true;

// Four leading spaces dictates that it's a gem version

// https://github.com/rubygems/bundler/blob/v2.1.4/lib/bundler/lockfile_parser.rb#L174-L181

let gem_version = Regex::new(r"^\s{4}([a-zA-Z\d\.\-_]+)\s\(([\d\w\.\-_]+)\)").unwrap();

let gemfile_path = format!("{}/{}", &self.workspace_path, "Gemfile.lock");

if let Ok(gemfile_contents) = fs::read_to_string(gemfile_path) {

let mut gem_paths = vec![];

let mut base_gem_path = "unset";

let gem_home_path_result = Command::new("sh")

.arg("-c")

// .arg(format!("eval \"$(/usr/local/bin/rbenv init -)\" && cd {} && gem environment home", &self.workspace_path))

.arg(format!(

"cd {} && gem environment home",

&self.workspace_path

))

.output();

if let Ok(gem_home_path) = gem_home_path_result {

if let Ok(gem_home_path) = str::from_utf8(gem_home_path.stdout.as_slice()) {

base_gem_path = gem_home_path;

}

// Index Ruby

let ruby_source_path = base_gem_path.replace("gems/", "").replace("\n", "");

info!("Added Ruby source path: {}", ruby_source_path);

gem_paths.push(ruby_source_path);

// Index Gems

for line in gemfile_contents.lines() {

if let Some(captures) = gem_version.captures(line) {

let name = captures[1].to_string();

let version = captures[2].to_string();

let gem_folder_name =

format!("{}/gems/{}-{}", base_gem_path, name, version);

// Not 100% sure where this newline is coming from. `gemfile_contents.lines()` I think.

let gem_folder_name = gem_folder_name.replace("\n", "");

info!("gem folder name: {}", gem_folder_name);

gem_paths.push(gem_folder_name)

}

}

}

let index = match &self.index {

Some(index) => index,

None => {

info!("missing index");

quit::with_code(1);

}

};

let mut index_writer = index.writer(256_000_000).unwrap();

for gem_path in gem_paths {

let walk_dir = WalkDirGeneric::<(usize, bool)>::new(gem_path.clone())

.process_read_dir(move |_depth, _path, _read_dir_state, children| {

children.retain(|dir_entry_result| {

dir_entry_result

.as_ref()

.map(|dir_entry| {

if let Some(file_name) = dir_entry.file_name.to_str() {

let ruby_file = file_name.ends_with(".rb");

dir_entry.file_type.is_dir() || ruby_file

} else {

false

}

})

.unwrap_or(false)

});

children.iter_mut().for_each(|dir_entry_result| {

if let Ok(dir_entry) = dir_entry_result {

if let Some(file_name) = dir_entry.file_name.to_str() {

if file_name.contains("node_modules")

|| file_name.contains("vendor")

|| file_name.contains("tmp")

|| file_name.contains(".git")

{

dir_entry.read_children_path = None;

}

}

}

});

});

let mut indexable_file_paths = Vec::new();

for entry in walk_dir {

let path = entry.unwrap().path();

let path = path.to_str().unwrap();

let ruby_file = path.ends_with(".rb");

if ruby_file {

indexable_file_paths.push(path.to_string());

}

}

for path in &indexable_file_paths {

if let Ok(text) = fs::read_to_string(&path) {

let uri = Url::from_file_path(&path).unwrap();

let relative_path = uri.path().replace(&self.workspace_path, "");

self.reindex_modified_file_without_commit(

&text,

relative_path,

&index_writer,

false,

);

}

}

}

index_writer.commit().unwrap();

} else {

info!("Gemfile not found, skipping indexing workspace gems.");

}

self.gems_indexed = true;

self.index_interface_only = false;

Ok(())

}

pub fn reindex_modified_file_without_commit(

&mut self,

text: &String,

relative_path: String,

index_writer: &IndexWriter,

user_space: bool,

) -> tantivy::Result<Vec<Option<tower_lsp::lsp_types::Diagnostic>>> {

if let Some(_) = &self.index {

let mut documents = Vec::new();

let diagnostics = match self.parse(text, &mut documents) {

Ok(diagnostics) => diagnostics,

Err(diagnostics) => {

// Return early so existing documents are not deleted when

// there is a syntax error

return Ok(diagnostics);

}

};

let file_path_id = blake3::hash(&relative_path.as_bytes());

for document in documents {

let mut fuzzy_doc = Document::default();

fuzzy_doc.add_text(self.schema_fields.file_path_id, &file_path_id.to_string());

for path_part in relative_path.split("/") {

if path_part.len() > 0 {

fuzzy_doc.add_text(self.schema_fields.file_path, path_part);

}

}

for fuzzy_scope in document.fuzzy_ruby_scope {

fuzzy_doc.add_text(self.schema_fields.fuzzy_ruby_scope_field, fuzzy_scope);

}

for class_scope in document.class_scope {

fuzzy_doc.add_text(self.schema_fields.class_scope_field, class_scope);

}

fuzzy_doc.add_text(

self.schema_fields.category_field,

document.category.to_string(),

);

fuzzy_doc.add_text(self.schema_fields.name_field, document.name);

fuzzy_doc.add_text(self.schema_fields.node_type_field, document.node_type);

fuzzy_doc.add_u64(

self.schema_fields.line_field,

document.line.try_into().unwrap(),

);

fuzzy_doc.add_u64(

self.schema_fields.start_column_field,

document.start_column.try_into().unwrap(),

);

fuzzy_doc.add_u64(

self.schema_fields.end_column_field,

document.end_column.try_into().unwrap(),

);

fuzzy_doc.add_bool(self.schema_fields.user_space_field, user_space);

let start_col = document.start_column;

let end_col = document.end_column;

let col_range = start_col..(end_col + 1);

for col in col_range {

fuzzy_doc.add_u64(self.schema_fields.columns_field, col as u64);

}

index_writer.add_document(fuzzy_doc)?;

}

Ok(diagnostics)

} else {

Ok(vec![])

}

}

pub async fn reindex_modified_file(&mut self, client: &Client, text: &String, uri: &Url) {

let mut documents = Vec::new();

let diagnostics = match self.parse(text, &mut documents) {

Ok(diagnostics) => diagnostics,

Err(diagnostics) => {

// Return early so existing documents are not deleted when

// there is a syntax error

// return Ok(diagnostics);

diagnostics

}

};

if self.report_diagnostics {

let mut reported_diagnostics = vec![];

for diagnostic in &diagnostics {

for unwrapped_diagnostic in diagnostic {

reported_diagnostics.push(unwrapped_diagnostic.clone());

}

}

client

.publish_diagnostics(uri.clone(), reported_diagnostics, None)

.await;

// .await;

}

if diagnostics.len() > 0 {

return;

}

if let Some(index) = &self.index {

let mut index_writer = index.writer_with_num_threads(1, 30_000_000).unwrap();

let user_space: bool;

let relative_path: String;

if uri.path().contains(&self.workspace_path) {

user_space = true;

relative_path = uri.path().replace(&self.workspace_path, "");

} else {

user_space = false;

relative_path = uri.path().to_string();

}

let file_path_id = blake3::hash(&relative_path.as_bytes());

let file_path_id_term =

Term::from_field_text(self.schema_fields.file_path_id, &file_path_id.to_string());

index_writer.delete_term(file_path_id_term);

for document in documents {

let mut fuzzy_doc = Document::default();

fuzzy_doc.add_text(self.schema_fields.file_path_id, &file_path_id.to_string());

for path_part in relative_path.split("/") {

if path_part.len() > 0 {

fuzzy_doc.add_text(self.schema_fields.file_path, path_part);

}

}

for fuzzy_scope in document.fuzzy_ruby_scope {

fuzzy_doc.add_text(self.schema_fields.fuzzy_ruby_scope_field, fuzzy_scope);

}

for class_scope in document.class_scope {

fuzzy_doc.add_text(self.schema_fields.class_scope_field, class_scope);

}

fuzzy_doc.add_text(

self.schema_fields.category_field,

document.category.to_string(),

);

fuzzy_doc.add_text(self.schema_fields.name_field, document.name);

fuzzy_doc.add_text(self.schema_fields.node_type_field, document.node_type);

fuzzy_doc.add_u64(

self.schema_fields.line_field,

document.line.try_into().unwrap(),

);

fuzzy_doc.add_u64(

self.schema_fields.start_column_field,

document.start_column.try_into().unwrap(),

);

fuzzy_doc.add_u64(

self.schema_fields.end_column_field,

document.end_column.try_into().unwrap(),

);

fuzzy_doc.add_bool(self.schema_fields.user_space_field, user_space);

let start_col = document.start_column;

let end_col = document.end_column;

let col_range = start_col..(end_col + 1);

for col in col_range {

fuzzy_doc.add_u64(self.schema_fields.columns_field, col as u64);

}

index_writer.add_document(fuzzy_doc).unwrap();

}

index_writer.commit().unwrap();

}

}

pub fn diagnostics(

&mut self,

text: &String,

_uri: &Url,

) -> tantivy::Result<Vec<Option<tower_lsp::lsp_types::Diagnostic>>> {

let mut documents = Vec::new();

match self.parse(text, &mut documents) {

Ok(diagnostics) => Ok(diagnostics),

Err(diagnostics) => Ok(diagnostics),

}

}

pub fn find_definitions(

&self,

params: TextDocumentPositionParams,

) -> tantivy::Result<Vec<Location>> {

let path = params.text_document.uri.path();

let relative_path = path.replace(&self.workspace_path, "");

let position = params.position;

if let Some(index) = &self.index {

let reader = index

.reader_builder()

.reload_policy(ReloadPolicy::OnCommit)

.try_into()?;

let searcher = reader.searcher();

let character_position = position.character;

let character_line = position.line;

let file_path_id = blake3::hash(&relative_path.as_bytes());

let file_path_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_text(self.schema_fields.file_path_id, &file_path_id.to_string()),

IndexRecordOption::Basic,

));

let category_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_text(self.schema_fields.category_field, "usage"),

IndexRecordOption::Basic,

));

let line_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_u64(self.schema_fields.line_field, character_line.into()),

IndexRecordOption::Basic,

));

let column_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_u64(self.schema_fields.columns_field, character_position.into()),

IndexRecordOption::Basic,

));

let query = BooleanQuery::new(vec![

(Occur::Must, file_path_query),

(Occur::Must, category_query),

(Occur::Must, line_query),

(Occur::Must, column_query),

]);

let usage_top_docs = searcher.search(&query, &TopDocs::with_limit(1))?;

let mut locations = Vec::new();

if usage_top_docs.len() == 0 {

info!("No usages docs found");

return Ok(locations);

}

let doc_address = usage_top_docs[0].1;

let retrieved_doc = searcher.doc(doc_address)?;

let category_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_text(self.schema_fields.category_field, "assignment"),

IndexRecordOption::Basic,

));

let usage_name = retrieved_doc

.get_first(self.schema_fields.name_field)

.unwrap()

.as_text()

.unwrap();

let usage_type = retrieved_doc

.get_first(self.schema_fields.node_type_field)

.unwrap()

.as_text()

.unwrap();

let name_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_text(self.schema_fields.name_field, usage_name),

IndexRecordOption::Basic,

));

let mut assignment_type_queries = vec![];

for possible_assignment_type in USAGE_TYPE_RESTRICTIONS.get(usage_type).unwrap().iter()

{

let assignment_type_query: Box<dyn Query> = Box::new(TermQuery::new(

Term::from_field_text(

self.schema_fields.node_type_field,

possible_assignment_type,

),

IndexRecordOption::Basic,

));

assignment_type_queries.push((Occur::Should, assignment_type_query));

}