Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use crate::{LanguageId, LanguageLoader, LanguageMatcher, LanguageName, ManifestName};
use collections::FxHashMap;
use globset::GlobSet;
use gpui::SharedString;
use smallvec::SmallVec;
use std::{cell::LazyCell, path::Path, sync::Arc};
use sum_tree::Bias;
use text::{Point, Rope};
use unicase::UniCase;
#[derive(Clone)]
pub struct AvailableLanguage {
pub(super) id: LanguageId,
pub(super) name: LanguageName,
pub(super) grammar: Option<Arc<str>>,
pub(super) matcher: Arc<LanguageMatcher>,
pub(super) hidden: bool,
pub(super) load: LanguageLoader,
pub(super) loaded: bool,
pub(super) manifest_name: Option<ManifestName>,
pub(super) origin: LanguageOrigin,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum LanguageOrigin {
Native,
Extension,
}
impl AvailableLanguage {
pub fn id(&self) -> LanguageId {
self.id
}
pub fn name(&self) -> LanguageName {
self.name.clone()
}
pub fn matcher(&self) -> &LanguageMatcher {
&self.matcher
}
pub fn hidden(&self) -> bool {
self.hidden
}
}
#[derive(Default)]
pub(super) struct AvailableLanguages(Vec<AvailableLanguage>);
#[derive(Copy, Clone, Default)]
enum LanguageMatchPrecedence {
#[default]
Undetermined,
PathOrContent(usize),
UserConfigured(usize),
}
impl AvailableLanguages {
pub(super) fn register(
&mut self,
name: LanguageName,
grammar: Option<Arc<str>>,
matcher: Arc<LanguageMatcher>,
hidden: bool,
manifest_name: Option<ManifestName>,
load: LanguageLoader,
origin: LanguageOrigin,
) -> Option<bool> {
if let Some(existing_language) = self
.0
.iter_mut()
.find(|existing_language| existing_language.name == name)
{
if origin == LanguageOrigin::Extension
&& existing_language.origin == LanguageOrigin::Native
{
return None;
}
existing_language.id = LanguageId::new();
existing_language.grammar = grammar;
existing_language.matcher = matcher;
existing_language.hidden = hidden;
existing_language.load = load;
existing_language.manifest_name = manifest_name;
existing_language.origin = origin;
let was_loaded = existing_language.loaded;
existing_language.loaded = false;
Some(was_loaded)
} else {
self.add(AvailableLanguage {
id: LanguageId::new(),
name,
grammar,
matcher,
hidden,
load,
loaded: false,
manifest_name,
origin,
});
Some(false)
}
}
pub(super) fn add(&mut self, language: AvailableLanguage) {
self.0.push(language);
}
pub(super) fn unloaded_language_names(&self) -> Vec<LanguageName> {
self.0
.iter()
.filter_map(|language| (!language.loaded).then_some(language.name.clone()))
.collect()
}
#[cfg(any(test, feature = "test-support"))]
pub(super) fn name_for_id(&self, id: LanguageId) -> Option<LanguageName> {
self.0
.iter()
.find(|language| language.id == id)
.map(|language| language.name.clone())
}
pub(super) fn get_language(&self, id: LanguageId) -> Option<&AvailableLanguage> {
self.0.iter().find(|language| language.id == id)
}
pub(super) fn find_name_by_extension(&self, extension: &str) -> Option<LanguageName> {
self.0
.iter()
.find(|language| {
language
.matcher
.path_suffixes
.iter()
.any(|suffix| suffix == extension)
})
.map(|language| language.name.clone())
}
pub(super) fn find_by_exact_name(&self, name: &str) -> Option<AvailableLanguage> {
self.0
.iter()
.find(|language| language.name.0.as_ref() == name)
.cloned()
}
pub(super) fn find_by_modeline_name(&self, modeline_name: &str) -> Option<AvailableLanguage> {
let modeline_name = modeline_name.to_lowercase();
self.0
.iter()
.find(|language| {
language
.matcher
.modeline_aliases
.iter()
.any(|alias| alias.to_lowercase() == modeline_name)
})
.or_else(|| {
self.0.iter().find(|language| {
language
.grammar
.as_ref()
.is_some_and(|grammar| grammar.to_lowercase() == modeline_name)
})
})
.or_else(|| {
self.0
.iter()
.find(|language| language.name.0.to_lowercase() == modeline_name)
})
.cloned()
}
pub(super) fn mark_all_unloaded(&mut self) {
for language in &mut self.0 {
language.loaded = false;
}
}
pub(super) fn remove_extension_languages(
&mut self,
names: &[LanguageName],
) -> Vec<LanguageName> {
let mut removed = Vec::new();
self.0.retain(|language| {
let should_remove =
language.origin == LanguageOrigin::Extension && names.contains(&language.name);
if should_remove {
removed.push(language.name.clone());
}
!should_remove
});
removed
}
pub(super) fn mark_loaded(&mut self, id: LanguageId) {
if let Some(language) = self.0.iter_mut().find(|language| language.id == id) {
language.loaded = true;
}
}
pub(super) fn find_by_name(&self, name: &str) -> Option<LanguageId> {
let name = UniCase::new(name);
self.find_best_match(
|language_name, _, current_best_match| match current_best_match {
LanguageMatchPrecedence::Undetermined if UniCase::new(&language_name.0) == name => {
Some(LanguageMatchPrecedence::PathOrContent(name.len()))
}
LanguageMatchPrecedence::Undetermined
| LanguageMatchPrecedence::UserConfigured(_)
| LanguageMatchPrecedence::PathOrContent(_) => None,
},
)
}
pub(super) fn find_by_name_or_extension(&self, string: &str) -> Option<LanguageId> {
let string = UniCase::new(string);
self.find_best_match(|name, matcher, current_best_match| {
let name_matches = || {
UniCase::new(&name.0) == string
|| matcher
.path_suffixes
.iter()
.any(|suffix| UniCase::new(suffix) == string)
};
match current_best_match {
LanguageMatchPrecedence::Undetermined => {
name_matches().then_some(LanguageMatchPrecedence::PathOrContent(string.len()))
}
LanguageMatchPrecedence::PathOrContent(len) => (string.len() > len
&& name_matches())
.then_some(LanguageMatchPrecedence::PathOrContent(string.len())),
LanguageMatchPrecedence::UserConfigured(_) => None,
}
})
}
pub(super) fn find_for_file(
&self,
filename: Option<&str>,
paths: &[&Path],
content: Option<&Rope>,
user_file_types: Option<&FxHashMap<Arc<str>, (GlobSet, Vec<String>)>>,
) -> Option<LanguageId> {
// `Path.extension()` returns None for files with a leading '.'
// and no other extension which is not the desired behavior here,
// as we want `.zshrc` to result in extension being `Some("zshrc")`
let extension = filename.and_then(|filename| filename.split('.').next_back());
let path_suffixes = [extension, filename]
.into_iter()
.chain(paths.iter().map(|path| path.to_str()))
.filter_map(|suffix| suffix.map(|suffix| (suffix, globset::Candidate::new(suffix))))
.collect::<SmallVec<[_; 6]>>();
let content = LazyCell::new(|| {
content.map(|content| {
let end = content.clip_point(Point::new(0, 256), Bias::Left);
let end = content.point_to_offset(end);
content.chunks_in_range(0..end).collect::<String>()
})
});
self.find_best_match(move |language_name, matcher, current_best_match| {
let path_matches_default_suffix = || {
let len = matcher.path_suffixes.iter().fold(
0,
|acc: usize, path_suffix: &SharedString| {
let ext = ".".to_string() + path_suffix;
let matched_suffix_len = path_suffixes
.iter()
.find(|(suffix, _)| {
suffix.ends_with(&ext) || *suffix == path_suffix.as_str()
})
.map(|(suffix, _)| suffix.len());
matched_suffix_len.map_or(acc, |len| acc.max(len))
},
);
(len > 0).then_some(len)
};
let path_matches_custom_suffix = || {
user_file_types
.and_then(|types| types.get(language_name.as_ref()))
.and_then(|(custom_suffixes, _)| {
path_suffixes
.iter()
.find(|(_, candidate)| custom_suffixes.is_match_candidate(candidate))
.map(|(suffix, _)| suffix.len())
})
};
let content_matches = || {
matcher.first_line_pattern.as_ref().is_some_and(|pattern| {
content
.as_ref()
.is_some_and(|content| pattern.is_match(content))
})
};
// Only return a match for the given file if we have a better match than
// the current one.
match current_best_match {
LanguageMatchPrecedence::PathOrContent(current_len) => {
if let Some(len) = path_matches_custom_suffix() {
// >= because user config should win tie with system ext len
(len >= current_len).then_some(LanguageMatchPrecedence::UserConfigured(len))
} else if let Some(len) = path_matches_default_suffix() {
// >= because user config should win tie with system ext len
(len >= current_len).then_some(LanguageMatchPrecedence::PathOrContent(len))
} else {
None
}
}
LanguageMatchPrecedence::Undetermined => {
if let Some(len) = path_matches_custom_suffix() {
Some(LanguageMatchPrecedence::UserConfigured(len))
} else if let Some(len) = path_matches_default_suffix() {
Some(LanguageMatchPrecedence::PathOrContent(len))
} else if content_matches() {
Some(LanguageMatchPrecedence::PathOrContent(1))
} else {
None
}
}
LanguageMatchPrecedence::UserConfigured(_) => None,
}
})
}
fn find_best_match(
&self,
callback: impl Fn(
&LanguageName,
&LanguageMatcher,
LanguageMatchPrecedence,
) -> Option<LanguageMatchPrecedence>,
) -> Option<LanguageId> {
self.0
.iter()
.rev()
.fold(None, |best_language_match, language| {
let current_match_type = best_language_match
.as_ref()
.map_or(LanguageMatchPrecedence::default(), |(_, score)| *score);
let language_score =
callback(&language.name, &language.matcher, current_match_type);
match (language_score, current_match_type) {
// no current best, so our candidate is better
(
Some(
LanguageMatchPrecedence::PathOrContent(_)
| LanguageMatchPrecedence::UserConfigured(_),
),
LanguageMatchPrecedence::Undetermined,
) => language_score.map(|new_score| (language, new_score)),
// our candidate is better only if the name is longer
(
Some(LanguageMatchPrecedence::PathOrContent(new_len)),
LanguageMatchPrecedence::PathOrContent(current_len),
)
| (
Some(LanguageMatchPrecedence::UserConfigured(new_len)),
LanguageMatchPrecedence::UserConfigured(current_len),
)
| (
Some(LanguageMatchPrecedence::PathOrContent(new_len)),
LanguageMatchPrecedence::UserConfigured(current_len),
) => {
if new_len > current_len {
language_score.map(|new_score| (language, new_score))
} else {
best_language_match
}
}
// our candidate is better if the name is longer or equal to
(
Some(LanguageMatchPrecedence::UserConfigured(new_len)),
LanguageMatchPrecedence::PathOrContent(current_len),
) => {
if new_len >= current_len {
language_score.map(|new_score| (language, new_score))
} else {
best_language_match
}
}
// no candidate, use current best
(None, _) | (Some(LanguageMatchPrecedence::Undetermined), _) => {
best_language_match
}
}
})
.map(|(available_language, _)| available_language.id())
}
}