Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use gpui::{App, AppContext, Task};
use language::{BufferSnapshot, Language, LanguageRegistry};
use std::sync::Arc;
const SAMPLE_BLOCK_SIZE: usize = 4096;
const MIN_LANGUAGE_DETECTION_CONFIDENCE: f32 = 0.2;
const MIN_LANGUAGE_DETECTION_CONFIDENCE_GAP: f32 = 0.2;
const MIN_LANGUAGE_SWITCH_CONFIDENCE_GAP: f32 = 0.5;
fn language_registry_key(language: betlang::Language) -> Option<&'static str> {
let language_name = match language {
betlang::Language::Asm => "Assembly",
betlang::Language::C => "C",
betlang::Language::Clojure => "Clojure",
betlang::Language::CMake => "CMake",
betlang::Language::Cobol => "COBOL",
betlang::Language::Cpp => "C++",
betlang::Language::Cs => "CSharp",
betlang::Language::Css => "CSS",
betlang::Language::Dart => "Dart",
betlang::Language::Dockerfile => "Dockerfile",
betlang::Language::Elixir => "Elixir",
betlang::Language::Erlang => "Erlang",
betlang::Language::Gemfile => "Ruby",
betlang::Language::Gemspec => "Ruby",
betlang::Language::Go => "Go",
betlang::Language::Gradle => "Groovy",
betlang::Language::Groovy => "Groovy",
betlang::Language::Haskell => "Haskell",
betlang::Language::Html => "HTML",
betlang::Language::Ini => "ini",
betlang::Language::Java => "Java",
betlang::Language::JavaScript => "JavaScript",
betlang::Language::Json => "JSON",
betlang::Language::Julia => "Julia",
betlang::Language::Kotlin => "Kotlin",
betlang::Language::Lua => "Lua",
betlang::Language::Markdown => "Markdown",
betlang::Language::ObjectiveC => "Objective-C",
betlang::Language::Ocaml => "OCaml",
betlang::Language::Perl => "Perl",
betlang::Language::Php => "PHP",
betlang::Language::Powershell => "PowerShell",
betlang::Language::Python => "Python",
betlang::Language::R => "R",
betlang::Language::Ruby => "Ruby",
betlang::Language::Rust => "Rust",
betlang::Language::Scala => "Scala",
betlang::Language::Shell => "Shell Script",
betlang::Language::Sql => "SQL",
betlang::Language::Swift => "Swift",
betlang::Language::Toml => "TOML",
betlang::Language::TypeScript => "TypeScript",
betlang::Language::Verilog => "SystemVerilog",
betlang::Language::Xml => "XML",
betlang::Language::Yaml => "YAML",
_ => return None,
};
Some(language_name)
}
pub fn detect_language(
buffer: BufferSnapshot,
language_registry: Arc<LanguageRegistry>,
cx: &mut App,
) -> Task<Option<Arc<Language>>> {
let source = extract_sample(&buffer);
let current_language_name = buffer.language().map(|language| language.name());
cx.background_spawn(async move {
let detection = betlang::detect(source);
let (mut pending_languages, mut confirmed_languages) = (Vec::new(), Vec::new());
// As in VS Code, retain only high-confidence candidate groups followed by a clear confidence gap.
for (score, language) in detection.top_languages() {
if pending_languages.last().is_some_and(|(previous_score, _)| {
*previous_score - score >= MIN_LANGUAGE_DETECTION_CONFIDENCE_GAP
}) {
confirmed_languages.append(&mut pending_languages);
}
if score < MIN_LANGUAGE_DETECTION_CONFIDENCE {
break;
}
pending_languages.push((score, language));
}
let detected_language =
confirmed_languages
.into_iter()
.find_map(|(score, model_language)| {
language_registry
.available_language_for_name(language_registry_key(model_language)?)
.map(|language| (score, language))
});
let Some((score, language)) = detected_language else {
return None;
};
if current_language_name == Some(language.name()) {
return None;
}
let current_language_score = current_language_name.and_then(|current_name| {
detection
.top_languages()
.find_map(|(score, model_language)| {
language_registry_key(model_language)
.is_some_and(|name| name == current_name.as_ref())
.then_some(score)
})
});
// Prefer the current language unless another candidate has a clear confidence advantage.
if current_language_score.is_some_and(|current_score| {
score <= current_score + MIN_LANGUAGE_SWITCH_CONFIDENCE_GAP
}) {
return None;
}
language_registry
.load_language(language.id())
.await
.ok()
.and_then(|language| language.ok())
})
}
fn extract_sample(buffer: &BufferSnapshot) -> Vec<u8> {
let source_length = buffer.len();
let ranges = if source_length <= SAMPLE_BLOCK_SIZE * 2 {
vec![0..source_length]
} else {
vec![
0..SAMPLE_BLOCK_SIZE,
source_length - SAMPLE_BLOCK_SIZE..source_length,
]
};
ranges
.into_iter()
.flat_map(|range| buffer.bytes_in_range(range))
.flat_map(|chunk| chunk.iter().copied())
.collect()
}