Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b
2026-04-28 08:43:33 -05:00
commit 0dbd3d567a
4982 changed files with 1431549 additions and 0 deletions
@@ -0,0 +1,87 @@
+//! Contains the implementation of internal suggestion generation logic that's coupled to the
+//! legacy command signature struct (`crate::signatures::CommandSignature`).
+use std::collections::HashMap;
+
+use crate::completer::{
+    engine::{self, CompletionLocation},
+    suggest::SuggestionTypeName,
+    CompleterOptions, CompletionContext, LocationType, MatchedSuggestion,
+};
+use crate::parsers::{ClassifiedCommand, SignatureAtTokenIndex};
+
+/// Returns a map of `SuggestionType` to vectors of `MatchedSuggestion`s for `line`.
+#[allow(clippy::too_many_arguments)]
+pub(super) async fn completion_results_from_locations(
+    line: &str,
+    classified_command: Option<ClassifiedCommand>,
+    tokens_from_command: &[&str],
+    found_signature: Option<SignatureAtTokenIndex<'_>>,
+    locations: Vec<CompletionLocation>,
+    session_env_vars: Option<&HashMap<String, String>>,
+    options: &CompleterOptions,
+    context: &dyn CompletionContext,
+) -> HashMap<SuggestionTypeName, Vec<MatchedSuggestion>> {
+    let mut completion_results_by_type =
+        HashMap::<SuggestionTypeName, Vec<MatchedSuggestion>>::new();
+
+    // For each location type, build up a single completion result for the
+    // corresponding suggestion type.
+    for location in locations {
+        match location.item {
+            LocationType::Command { parsed_token, .. } => {
+                let results =
+                    engine::command_suggestions(context, options.match_strategy, &parsed_token)
+                        .await;
+                completion_results_by_type
+                    .entry(SuggestionTypeName::Command)
+                    .or_default()
+                    .extend(results);
+            }
+            LocationType::Variable { parsed_token } => {
+                if let Some(env_vars) = context.environment_variable_names() {
+                    let results = engine::variable_suggestions(
+                        options.match_strategy,
+                        env_vars,
+                        &parsed_token,
+                    );
+                    completion_results_by_type
+                        .entry(SuggestionTypeName::Variable)
+                        .or_default()
+                        .extend(results);
+                }
+            }
+            LocationType::Flag { .. } => {
+                let results =
+                    engine::flag_suggestions(options.match_strategy, &location, found_signature);
+                completion_results_by_type
+                    .entry(SuggestionTypeName::Option)
+                    .or_default()
+                    .extend(results);
+            }
+            LocationType::Argument {
+                ref parsed_token, ..
+            } => {
+                if let Some(classified_command) = classified_command.as_ref() {
+                    let results = engine::argument_suggestions(
+                        line,
+                        tokens_from_command,
+                        classified_command.clone(),
+                        found_signature,
+                        &location,
+                        parsed_token,
+                        session_env_vars,
+                        options,
+                        context,
+                    )
+                    .await;
+                    completion_results_by_type
+                        .entry(SuggestionTypeName::Argument)
+                        .or_default()
+                        .extend(results);
+                }
+            }
+        }
+    }
+
+    completion_results_by_type
+}