[ty] Add None, True and False to scoped completions

This doesn't implement fully context aware keyword completions, but it
does let us include the 3 keywords that are also values in completions.

This helps improve the completion experience when trying to write one of
these values in the ty playground.

Ranking could still be improved here. We haven't yet devised a mechanism
for ranking "builtin" symbols above others. It's even plausible that
these _particular_ symbols should get special treatment over and above
others.

Author: BurntSushi

crates/ty_completion_eval/completion-evaluation-tasks.csv

@@ -5,7 +5,7 @@ higher-level-symbols-preferred,main.py,1,1
 import-deprioritizes-dunder,main.py,0,1
 import-deprioritizes-sunder,main.py,0,1
 internal-typeshed-hidden,main.py,0,4
-none-completion,main.py,0,
+none-completion,main.py,0,11
 numpy-array,main.py,0,
 numpy-array,main.py,1,1
 object-attr-instance-methods,main.py,0,1

crates/ty_ide/src/completion.rs

@@ -9,6 +9,7 @@ use ruff_python_ast::name::Name;
 use ruff_python_codegen::Stylist;
 use ruff_python_parser::{Token, TokenAt, TokenKind, Tokens};
 use ruff_text_size::{Ranged, TextRange, TextSize};
+use ty_python_semantic::types::KnownClass;
 use ty_python_semantic::{
     Completion as SemanticCompletion, ModuleName, NameKind, SemanticModel,
     types::{CycleDetector, Type},
@@ -252,6 +253,9 @@ pub fn completion<'db>(
         .map(|c| Completion::from_semantic_completion(db, c))
         .collect();
 
+    if scoped.is_some() {
+        add_keyword_value_completions(db, &typed_query, &mut completions);
+    }
     if settings.auto_import {
         if let Some(scoped) = scoped {
             add_unimported_completions(
@@ -269,6 +273,37 @@ pub fn completion<'db>(
     completions
 }
 
+/// Adds a subset of completions derived from keywords.
+///
+/// Note that at present, these should only be added to "scoped"
+/// completions. i.e., This will include `None`, `True`, `False`, etc.
+fn add_keyword_value_completions<'db>(
+    db: &'db dyn Db,
+    query: &QueryPattern,
+    completions: &mut Vec<Completion<'db>>,
+) {
+    let keywords = [
+        ("None", KnownClass::NoneType),
+        ("True", KnownClass::Bool),
+        ("False", KnownClass::Bool),
+    ];
+    for (name, known) in keywords {
+        if !query.is_match_symbol_name(name) {
+            continue;
+        }
+        completions.push(Completion {
+            name: ast::name::Name::new(name),
+            insert: None,
+            ty: Some(known.to_class_literal(db)),
+            kind: None,
+            module_name: None,
+            import: None,
+            builtin: true,
+            documentation: None,
+        });
+    }
+}
+
 /// Adds completions not in scope.
 ///
 /// `scoped` should be information about the identified scope

crates/ty_python_semantic/src/types.rs

@@ -66,7 +66,7 @@ use crate::types::visitor::any_over_type;
 use crate::unpack::EvaluationMode;
 pub use crate::util::diagnostics::add_inferred_python_version_hint_to_diagnostic;
 use crate::{Db, FxOrderSet, Module, Program};
-pub(crate) use class::{ClassLiteral, ClassType, GenericAlias, KnownClass};
+pub use class::{ClassLiteral, ClassType, GenericAlias, KnownClass};
 use instance::Protocol;
 pub use instance::{NominalInstanceType, ProtocolInstanceType};
 pub use special_form::SpecialFormType;

crates/ty_python_semantic/src/types/class.rs

@@ -4576,7 +4576,7 @@ impl KnownClass {
     /// Lookup a [`KnownClass`] in typeshed and return a [`Type`] representing that class-literal.
     ///
     /// If the class cannot be found in typeshed, a debug-level log message will be emitted stating this.
-    pub(crate) fn to_class_literal(self, db: &dyn Db) -> Type<'_> {
+    pub fn to_class_literal(self, db: &dyn Db) -> Type<'_> {
         self.try_to_class_literal(db)
             .map(Type::ClassLiteral)
             .unwrap_or_else(Type::unknown)