From c182c5fadcf19250147100f95abe80668f249f23 Mon Sep 17 00:00:00 2001 From: Myriad-Dreamin <35292584+Myriad-Dreamin@users.noreply.github.com> Date: Thu, 16 May 2024 00:30:32 +0800 Subject: [PATCH] chore: move typst-specific types (#294) * chore: move typst-specific types * QAQ --- crates/tinymist-query/src/adt/interner.rs | 2 + crates/tinymist-query/src/analysis/ty.rs | 107 ++++------ .../tinymist-query/src/analysis/ty/syntax.rs | 192 +++++++++--------- crates/tinymist-query/src/ty/builtin.rs | 42 +++- crates/tinymist-query/src/ty/def.rs | 22 +- crates/tinymist-query/src/ty/describe.rs | 15 +- crates/tinymist-query/src/ty/mutate.rs | 8 - crates/tinymist-query/src/ty/simplify.rs | 16 -- crates/tinymist-query/src/ty/subst.rs | 15 +- .../src/upstream/complete/ext.rs | 31 +-- tests/e2e/main.rs | 2 +- 11 files changed, 201 insertions(+), 251 deletions(-) diff --git a/crates/tinymist-query/src/adt/interner.rs b/crates/tinymist-query/src/adt/interner.rs index fbce0847..f821592f 100644 --- a/crates/tinymist-query/src/adt/interner.rs +++ b/crates/tinymist-query/src/adt/interner.rs @@ -35,6 +35,8 @@ type Guard = dashmap::RwLockWriteGuard< HashMap, SharedValue<()>, BuildHasherDefault>, >; +// https://news.ycombinator.com/item?id=22220342 + pub struct Interned { arc: Arc, } diff --git a/crates/tinymist-query/src/analysis/ty.rs b/crates/tinymist-query/src/analysis/ty.rs index c302e6db..386ed247 100644 --- a/crates/tinymist-query/src/analysis/ty.rs +++ b/crates/tinymist-query/src/analysis/ty.rs @@ -72,7 +72,7 @@ struct TypeChecker<'a, 'w> { impl<'a, 'w> TypeChecker<'a, 'w> { fn check(&mut self, root: LinkedNode) -> Ty { let should_record = matches!(root.kind(), SyntaxKind::FuncCall).then(|| root.span()); - let w = self.check_syntax(root).unwrap_or(Ty::Undef); + let w = self.check_syntax(root).unwrap_or(Ty::undef()); if let Some(s) = should_record { self.info.witness_at_least(s, w.clone()); @@ -324,14 +324,7 @@ impl<'a, 'w> TypeChecker<'a, 'w> { fn possible_ever_be(&mut self, lhs: &Ty, rhs: &Ty) { // todo: instantiataion match rhs { - Ty::Undef - | Ty::Content - | Ty::None - | Ty::FlowNone - | Ty::Auto - | Ty::Builtin(..) - | Ty::Value(..) - | Ty::Boolean(..) => { + Ty::Builtin(..) | Ty::Value(..) | Ty::Boolean(..) => { self.constrain(rhs, lhs); } _ => {} @@ -374,18 +367,7 @@ impl<'a, 'w> TypeChecker<'a, 'w> { let w = self.info.vars.get_mut(&v.def).unwrap(); w.weaken(); } - Ty::Clause - | Ty::Undef - | Ty::Content - | Ty::Any - | Ty::Space - | Ty::None - | Ty::Infer - | Ty::FlowNone - | Ty::Auto - | Ty::Boolean(_) - | Ty::Builtin(_) - | Ty::Value(_) => {} + Ty::Any | Ty::Boolean(_) | Ty::Builtin(_) | Ty::Value(_) => {} Ty::Field(v) => { self.weaken(&v.field); } @@ -496,55 +478,46 @@ impl Joiner { } match (child, &self.definite) { - (Ty::Clause, _) => {} - (Ty::Undef, _) => {} - (Ty::Space, _) => {} + (Ty::Builtin(BuiltinTy::Space | BuiltinTy::None), _) => {} + (Ty::Builtin(BuiltinTy::Clause | BuiltinTy::FlowNone), _) => {} (Ty::Any, _) | (_, Ty::Any) => {} - (Ty::Infer, _) => {} - (Ty::None, _) => {} - // todo: mystery flow none - (Ty::FlowNone, _) => {} - (Ty::Content, Ty::Content) => {} - (Ty::Content, Ty::None) => self.definite = Ty::Content, - (Ty::Content, _) => self.definite = Ty::Undef, (Ty::Var(v), _) => self.possibles.push(Ty::Var(v)), // todo: check possibles - (Ty::Array(e), Ty::None) => self.definite = Ty::Array(e), - (Ty::Array(..), _) => self.definite = Ty::Undef, - (Ty::Tuple(e), Ty::None) => self.definite = Ty::Tuple(e), - (Ty::Tuple(..), _) => self.definite = Ty::Undef, - // todo: possible some style - (Ty::Auto, Ty::None) => self.definite = Ty::Auto, - (Ty::Auto, _) => self.definite = Ty::Undef, - (Ty::Builtin(b), Ty::None) => self.definite = Ty::Builtin(b), - (Ty::Builtin(..), _) => self.definite = Ty::Undef, + (Ty::Array(e), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Array(e), + (Ty::Array(..), _) => self.definite = Ty::undef(), + (Ty::Tuple(e), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Tuple(e), + (Ty::Tuple(..), _) => self.definite = Ty::undef(), + // todo: mystery flow none + // todo: possible some style (auto) + (Ty::Builtin(b), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Builtin(b), + (Ty::Builtin(..), _) => self.definite = Ty::undef(), // todo: value join - (Ty::Value(v), Ty::None) => self.definite = Ty::Value(v), - (Ty::Value(..), _) => self.definite = Ty::Undef, - (Ty::Func(f), Ty::None) => self.definite = Ty::Func(f), - (Ty::Func(..), _) => self.definite = Ty::Undef, - (Ty::Dict(w), Ty::None) => self.definite = Ty::Dict(w), - (Ty::Dict(..), _) => self.definite = Ty::Undef, - (Ty::With(w), Ty::None) => self.definite = Ty::With(w), - (Ty::With(..), _) => self.definite = Ty::Undef, - (Ty::Args(w), Ty::None) => self.definite = Ty::Args(w), - (Ty::Args(..), _) => self.definite = Ty::Undef, - (Ty::Select(w), Ty::None) => self.definite = Ty::Select(w), - (Ty::Select(..), _) => self.definite = Ty::Undef, - (Ty::Unary(w), Ty::None) => self.definite = Ty::Unary(w), - (Ty::Unary(..), _) => self.definite = Ty::Undef, - (Ty::Binary(w), Ty::None) => self.definite = Ty::Binary(w), - (Ty::Binary(..), _) => self.definite = Ty::Undef, - (Ty::If(w), Ty::None) => self.definite = Ty::If(w), - (Ty::If(..), _) => self.definite = Ty::Undef, - (Ty::Union(w), Ty::None) => self.definite = Ty::Union(w), - (Ty::Union(..), _) => self.definite = Ty::Undef, - (Ty::Let(w), Ty::None) => self.definite = Ty::Let(w), - (Ty::Let(..), _) => self.definite = Ty::Undef, - (Ty::Field(w), Ty::None) => self.definite = Ty::Field(w), - (Ty::Field(..), _) => self.definite = Ty::Undef, - (Ty::Boolean(b), Ty::None) => self.definite = Ty::Boolean(b), - (Ty::Boolean(..), _) => self.definite = Ty::Undef, + (Ty::Value(v), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Value(v), + (Ty::Value(..), _) => self.definite = Ty::undef(), + (Ty::Func(f), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Func(f), + (Ty::Func(..), _) => self.definite = Ty::undef(), + (Ty::Dict(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Dict(w), + (Ty::Dict(..), _) => self.definite = Ty::undef(), + (Ty::With(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::With(w), + (Ty::With(..), _) => self.definite = Ty::undef(), + (Ty::Args(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Args(w), + (Ty::Args(..), _) => self.definite = Ty::undef(), + (Ty::Select(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Select(w), + (Ty::Select(..), _) => self.definite = Ty::undef(), + (Ty::Unary(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Unary(w), + (Ty::Unary(..), _) => self.definite = Ty::undef(), + (Ty::Binary(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Binary(w), + (Ty::Binary(..), _) => self.definite = Ty::undef(), + (Ty::If(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::If(w), + (Ty::If(..), _) => self.definite = Ty::undef(), + (Ty::Union(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Union(w), + (Ty::Union(..), _) => self.definite = Ty::undef(), + (Ty::Let(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Let(w), + (Ty::Let(..), _) => self.definite = Ty::undef(), + (Ty::Field(w), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Field(w), + (Ty::Field(..), _) => self.definite = Ty::undef(), + (Ty::Boolean(b), Ty::Builtin(BuiltinTy::None)) => self.definite = Ty::Boolean(b), + (Ty::Boolean(..), _) => self.definite = Ty::undef(), } } } @@ -552,7 +525,7 @@ impl Default for Joiner { fn default() -> Self { Self { break_or_continue_or_return: false, - definite: Ty::None, + definite: Ty::Builtin(BuiltinTy::None), possibles: Vec::new(), } } diff --git a/crates/tinymist-query/src/analysis/ty/syntax.rs b/crates/tinymist-query/src/analysis/ty/syntax.rs index 713416c0..e1964ab0 100644 --- a/crates/tinymist-query/src/analysis/ty/syntax.rs +++ b/crates/tinymist-query/src/analysis/ty/syntax.rs @@ -23,28 +23,28 @@ impl<'a, 'w> TypeChecker<'a, 'w> { SyntaxKind::ContentBlock => return self.check_in_mode(root, InterpretMode::Markup), // todo: space effect - SyntaxKind::Space => Ty::Space, - SyntaxKind::Parbreak => Ty::Space, + SyntaxKind::Space => Ty::Builtin(BuiltinTy::Space), + SyntaxKind::Parbreak => Ty::Builtin(BuiltinTy::Space), - SyntaxKind::Text => Ty::Content, - SyntaxKind::Linebreak => Ty::Content, - SyntaxKind::Escape => Ty::Content, - SyntaxKind::Shorthand => Ty::Content, - SyntaxKind::SmartQuote => Ty::Content, - SyntaxKind::Raw => Ty::Content, - SyntaxKind::RawLang => Ty::Content, - SyntaxKind::RawDelim => Ty::Content, - SyntaxKind::RawTrimmed => Ty::Content, - SyntaxKind::Link => Ty::Content, - SyntaxKind::Label => Ty::Content, - SyntaxKind::Ref => Ty::Content, - SyntaxKind::RefMarker => Ty::Content, - SyntaxKind::HeadingMarker => Ty::Content, - SyntaxKind::EnumMarker => Ty::Content, - SyntaxKind::ListMarker => Ty::Content, - SyntaxKind::TermMarker => Ty::Content, - SyntaxKind::MathAlignPoint => Ty::Content, - SyntaxKind::MathPrimes => Ty::Content, + SyntaxKind::Text => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Linebreak => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Escape => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Shorthand => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::SmartQuote => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Raw => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::RawLang => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::RawDelim => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::RawTrimmed => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Link => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Label => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::Ref => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::RefMarker => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::HeadingMarker => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::EnumMarker => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::ListMarker => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::TermMarker => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::MathAlignPoint => Ty::Builtin(BuiltinTy::Content), + SyntaxKind::MathPrimes => Ty::Builtin(BuiltinTy::Content), SyntaxKind::Strong => return self.check_children(root), SyntaxKind::Emph => return self.check_children(root), @@ -58,17 +58,17 @@ impl<'a, 'w> TypeChecker<'a, 'w> { SyntaxKind::MathFrac => return self.check_children(root), SyntaxKind::MathRoot => return self.check_children(root), - SyntaxKind::LoopBreak => Ty::None, - SyntaxKind::LoopContinue => Ty::None, - SyntaxKind::FuncReturn => Ty::None, - SyntaxKind::Error => Ty::None, - SyntaxKind::Eof => Ty::None, + SyntaxKind::LoopBreak => Ty::Builtin(BuiltinTy::None), + SyntaxKind::LoopContinue => Ty::Builtin(BuiltinTy::None), + SyntaxKind::FuncReturn => Ty::Builtin(BuiltinTy::None), + SyntaxKind::Error => Ty::Builtin(BuiltinTy::None), + SyntaxKind::Eof => Ty::Builtin(BuiltinTy::None), - SyntaxKind::None => Ty::None, - SyntaxKind::Auto => Ty::Auto, - SyntaxKind::Break => Ty::FlowNone, - SyntaxKind::Continue => Ty::FlowNone, - SyntaxKind::Return => Ty::FlowNone, + SyntaxKind::None => Ty::Builtin(BuiltinTy::None), + SyntaxKind::Auto => Ty::Builtin(BuiltinTy::Auto), + SyntaxKind::Break => Ty::Builtin(BuiltinTy::FlowNone), + SyntaxKind::Continue => Ty::Builtin(BuiltinTy::FlowNone), + SyntaxKind::Return => Ty::Builtin(BuiltinTy::FlowNone), SyntaxKind::Ident => return self.check_ident(root, InterpretMode::Code), SyntaxKind::MathIdent => return self.check_ident(root, InterpretMode::Math), SyntaxKind::Bool @@ -103,62 +103,62 @@ impl<'a, 'w> TypeChecker<'a, 'w> { SyntaxKind::DestructAssignment => return self.check_destruct_assign(root), // Rest all are clauses - SyntaxKind::LineComment => Ty::Clause, - SyntaxKind::BlockComment => Ty::Clause, - SyntaxKind::Named => Ty::Clause, - SyntaxKind::Keyed => Ty::Clause, - SyntaxKind::Spread => Ty::Clause, - SyntaxKind::Params => Ty::Clause, - SyntaxKind::ImportItems => Ty::Clause, - SyntaxKind::RenamedImportItem => Ty::Clause, - SyntaxKind::Hash => Ty::Clause, - SyntaxKind::LeftBrace => Ty::Clause, - SyntaxKind::RightBrace => Ty::Clause, - SyntaxKind::LeftBracket => Ty::Clause, - SyntaxKind::RightBracket => Ty::Clause, - SyntaxKind::LeftParen => Ty::Clause, - SyntaxKind::RightParen => Ty::Clause, - SyntaxKind::Comma => Ty::Clause, - SyntaxKind::Semicolon => Ty::Clause, - SyntaxKind::Colon => Ty::Clause, - SyntaxKind::Star => Ty::Clause, - SyntaxKind::Underscore => Ty::Clause, - SyntaxKind::Dollar => Ty::Clause, - SyntaxKind::Plus => Ty::Clause, - SyntaxKind::Minus => Ty::Clause, - SyntaxKind::Slash => Ty::Clause, - SyntaxKind::Hat => Ty::Clause, - SyntaxKind::Prime => Ty::Clause, - SyntaxKind::Dot => Ty::Clause, - SyntaxKind::Eq => Ty::Clause, - SyntaxKind::EqEq => Ty::Clause, - SyntaxKind::ExclEq => Ty::Clause, - SyntaxKind::Lt => Ty::Clause, - SyntaxKind::LtEq => Ty::Clause, - SyntaxKind::Gt => Ty::Clause, - SyntaxKind::GtEq => Ty::Clause, - SyntaxKind::PlusEq => Ty::Clause, - SyntaxKind::HyphEq => Ty::Clause, - SyntaxKind::StarEq => Ty::Clause, - SyntaxKind::SlashEq => Ty::Clause, - SyntaxKind::Dots => Ty::Clause, - SyntaxKind::Arrow => Ty::Clause, - SyntaxKind::Root => Ty::Clause, - SyntaxKind::Not => Ty::Clause, - SyntaxKind::And => Ty::Clause, - SyntaxKind::Or => Ty::Clause, - SyntaxKind::Let => Ty::Clause, - SyntaxKind::Set => Ty::Clause, - SyntaxKind::Show => Ty::Clause, - SyntaxKind::Context => Ty::Clause, - SyntaxKind::If => Ty::Clause, - SyntaxKind::Else => Ty::Clause, - SyntaxKind::For => Ty::Clause, - SyntaxKind::In => Ty::Clause, - SyntaxKind::While => Ty::Clause, - SyntaxKind::Import => Ty::Clause, - SyntaxKind::Include => Ty::Clause, - SyntaxKind::As => Ty::Clause, + SyntaxKind::LineComment => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::BlockComment => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Named => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Keyed => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Spread => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Params => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::ImportItems => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::RenamedImportItem => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Hash => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::LeftBrace => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::RightBrace => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::LeftBracket => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::RightBracket => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::LeftParen => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::RightParen => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Comma => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Semicolon => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Colon => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Star => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Underscore => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Dollar => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Plus => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Minus => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Slash => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Hat => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Prime => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Dot => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Eq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::EqEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::ExclEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Lt => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::LtEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Gt => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::GtEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::PlusEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::HyphEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::StarEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::SlashEq => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Dots => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Arrow => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Root => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Not => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::And => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Or => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Let => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Set => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Show => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Context => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::If => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Else => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::For => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::In => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::While => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Import => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::Include => Ty::Builtin(BuiltinTy::Clause), + SyntaxKind::As => Ty::Builtin(BuiltinTy::Clause), }) } @@ -200,7 +200,7 @@ impl<'a, 'w> TypeChecker<'a, 'w> { for elem in root.children() { let ty = self.check(elem); - if matches!(ty, Ty::Clause | Ty::Space) { + if matches!(ty, Ty::Builtin(BuiltinTy::Clause | BuiltinTy::Space)) { continue; } elements.push(ty); @@ -421,7 +421,7 @@ impl<'a, 'w> TypeChecker<'a, 'w> { let value = let_binding .init() .map(|init| self.check_expr_in(init.span(), root.clone())) - .unwrap_or_else(|| Ty::Infer); + .unwrap_or_else(|| Ty::Builtin(BuiltinTy::Infer)); let v = self.get_var(c.span(), to_ident_ref(&root, c)?)?; self.constrain(&value, &v); @@ -432,7 +432,7 @@ impl<'a, 'w> TypeChecker<'a, 'w> { let value = let_binding .init() .map(|init| self.check_expr_in(init.span(), root.clone())) - .unwrap_or_else(|| Ty::Infer); + .unwrap_or_else(|| Ty::Builtin(BuiltinTy::Infer)); self.check_pattern(pattern, value, root.clone()); } @@ -497,7 +497,7 @@ impl<'a, 'w> TypeChecker<'a, 'w> { let else_ = conditional .else_body() .map(|else_body| self.check_expr_in(else_body.span(), root.clone())) - .unwrap_or(Ty::None); + .unwrap_or(Ty::Builtin(BuiltinTy::None)); Some(Ty::If(IfTy::new(cond.into(), then.into(), else_.into()))) } @@ -526,11 +526,11 @@ impl<'a, 'w> TypeChecker<'a, 'w> { // check all import items - Some(Ty::None) + Some(Ty::Builtin(BuiltinTy::None)) } fn check_module_include(&mut self, _root: LinkedNode<'_>) -> Option { - Some(Ty::Content) + Some(Ty::Builtin(BuiltinTy::Content)) } fn check_destructuring(&mut self, _root: LinkedNode<'_>) -> Option { @@ -538,17 +538,17 @@ impl<'a, 'w> TypeChecker<'a, 'w> { } fn check_destruct_assign(&mut self, _root: LinkedNode<'_>) -> Option { - Some(Ty::None) + Some(Ty::Builtin(BuiltinTy::None)) } fn check_expr_in(&mut self, span: Span, root: LinkedNode<'_>) -> Ty { root.find(span) .map(|node| self.check(node)) - .unwrap_or(Ty::Undef) + .unwrap_or(Ty::Builtin(BuiltinTy::Undef)) } fn check_pattern(&mut self, pattern: ast::Pattern<'_>, value: Ty, root: LinkedNode<'_>) -> Ty { self.check_pattern_(pattern, value, root) - .unwrap_or(Ty::Undef) + .unwrap_or(Ty::Builtin(BuiltinTy::Undef)) } fn check_pattern_( diff --git a/crates/tinymist-query/src/ty/builtin.rs b/crates/tinymist-query/src/ty/builtin.rs index 63dd7db2..cccbb236 100644 --- a/crates/tinymist-query/src/ty/builtin.rs +++ b/crates/tinymist-query/src/ty/builtin.rs @@ -160,6 +160,15 @@ impl<'a> Iterator for UnionIter<'a> { #[derive(Clone, Hash, PartialEq, Eq)] pub(crate) enum BuiltinTy { + Clause, + Undef, + Content, + Space, + None, + Infer, + FlowNone, + Auto, + Args, Color, TextSize, @@ -185,6 +194,15 @@ pub(crate) enum BuiltinTy { impl fmt::Debug for BuiltinTy { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { + BuiltinTy::Clause => f.write_str("Clause"), + BuiltinTy::Undef => f.write_str("Undef"), + BuiltinTy::Content => f.write_str("Content"), + BuiltinTy::Space => f.write_str("Space"), + BuiltinTy::None => f.write_str("None"), + BuiltinTy::Infer => f.write_str("Infer"), + BuiltinTy::FlowNone => f.write_str("FlowNone"), + BuiltinTy::Auto => f.write_str("Auto"), + BuiltinTy::Args => write!(f, "Args"), BuiltinTy::Color => write!(f, "Color"), BuiltinTy::TextSize => write!(f, "TextSize"), @@ -217,16 +235,16 @@ impl BuiltinTy { pub fn from_builtin(builtin: Type) -> Ty { if builtin == Type::of::() { - return Ty::Auto; + return Ty::Builtin(BuiltinTy::Auto); } if builtin == Type::of::() { - return Ty::None; + return Ty::Builtin(BuiltinTy::None); } if builtin == Type::of::() { return Color.literally(); } if builtin == Type::of::() { - return Ty::None; + return Ty::Builtin(BuiltinTy::None); } if builtin == Type::of::() { return Float.literally(); @@ -235,7 +253,7 @@ impl BuiltinTy { return Length.literally(); } if builtin == Type::of::() { - return Ty::Content; + return Ty::Builtin(BuiltinTy::Content); } BuiltinTy::Type(builtin).literally() @@ -243,6 +261,15 @@ impl BuiltinTy { pub(crate) fn describe(&self) -> &'static str { match self { + BuiltinTy::Clause => "any", + BuiltinTy::Undef => "any", + BuiltinTy::Content => "content", + BuiltinTy::Space => "content", + BuiltinTy::None => "none", + BuiltinTy::Infer => "any", + BuiltinTy::FlowNone => "none", + BuiltinTy::Auto => "auto", + BuiltinTy::Args => "args", BuiltinTy::Color => "color", BuiltinTy::TextSize => "text.size", @@ -406,7 +433,7 @@ pub(super) fn param_mapping(f: &Func, p: &ParamInfo) -> Option { "stroke", ) => Some(Ty::Builtin(Stroke)), ("page", "margin") => Some(Ty::Builtin(Margin)), - _ => None, + _ => Option::None, } } @@ -521,8 +548,9 @@ mod tests { fn test_map() { let u = Ty::Var(TypeVar::new("u".into(), DefId(0))); let v = Ty::Var(TypeVar::new("v".into(), DefId(1))); - let mapper_fn = Ty::Func(SigTy::new([u], None, None, Some(v.clone())).into()); - let map_fn = Ty::Func(SigTy::new([mapper_fn], None, None, Some(v)).into()); + let mapper_fn = + Ty::Func(SigTy::new([u], Option::None, Option::None, Some(v.clone())).into()); + let map_fn = Ty::Func(SigTy::new([mapper_fn], Option::None, Option::None, Some(v)).into()); let _ = map_fn; // println!("{map_fn:?}"); } diff --git a/crates/tinymist-query/src/ty/def.rs b/crates/tinymist-query/src/ty/def.rs index 40c419a3..55cd0550 100644 --- a/crates/tinymist-query/src/ty/def.rs +++ b/crates/tinymist-query/src/ty/def.rs @@ -768,15 +768,7 @@ impl IfTy { #[derive(Hash, Clone, PartialEq, Eq)] pub(crate) enum Ty { - Clause, - Undef, - Content, Any, - Space, - None, - Infer, - FlowNone, - Auto, Boolean(Option), Builtin(BuiltinTy), Value(Interned), @@ -802,15 +794,7 @@ pub(crate) enum Ty { impl fmt::Debug for Ty { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - Ty::Clause => f.write_str("Clause"), - Ty::Undef => f.write_str("Undef"), - Ty::Content => f.write_str("Content"), Ty::Any => f.write_str("Any"), - Ty::Space => f.write_str("Space"), - Ty::None => f.write_str("None"), - Ty::Infer => f.write_str("Infer"), - Ty::FlowNone => f.write_str("FlowNone"), - Ty::Auto => f.write_str("Auto"), Ty::Builtin(t) => write!(f, "{t:?}"), Ty::Args(a) => write!(f, "&({a:?})"), Ty::Func(s) => write!(f, "{s:?}"), @@ -872,6 +856,10 @@ impl Ty { pub(crate) fn iter_union(e: impl IntoIterator) -> Self { Ty::Union(Interned::new(e.into_iter().collect())) } + + pub const fn undef() -> Self { + Ty::Builtin(BuiltinTy::Undef) + } } impl_internable!(Ty,); @@ -915,7 +903,7 @@ mod tests { #[test] fn test_ty() { use super::*; - let ty = Ty::Clause; + let ty = Ty::Builtin(BuiltinTy::Clause); let ty_ref = TyRef::new(ty.clone()); assert_debug_snapshot!(ty_ref, @"Clause"); } diff --git a/crates/tinymist-query/src/ty/describe.rs b/crates/tinymist-query/src/ty/describe.rs index 10b902e4..b4bf81a3 100644 --- a/crates/tinymist-query/src/ty/describe.rs +++ b/crates/tinymist-query/src/ty/describe.rs @@ -137,22 +137,15 @@ impl TypeDescriber { Ty::With(w) => { return self.describe(&w.sig); } - Ty::Clause => {} - Ty::Undef => {} - Ty::Content => { + Ty::Builtin(BuiltinTy::Content | BuiltinTy::Space) => { return "content".to_string(); } // Doesn't provide any information, hence we doesn't describe it intermediately here. - Ty::Any => {} - Ty::Space => {} - Ty::None => { + Ty::Any | Ty::Builtin(BuiltinTy::Clause | BuiltinTy::Undef | BuiltinTy::Infer) => {} + Ty::Builtin(BuiltinTy::FlowNone | BuiltinTy::None) => { return "none".to_string(); } - Ty::Infer => {} - Ty::FlowNone => { - return "none".to_string(); - } - Ty::Auto => { + Ty::Builtin(BuiltinTy::Auto) => { return "auto".to_string(); } Ty::Boolean(None) => { diff --git a/crates/tinymist-query/src/ty/mutate.rs b/crates/tinymist-query/src/ty/mutate.rs index 8c1263e1..255a9cae 100644 --- a/crates/tinymist-query/src/ty/mutate.rs +++ b/crates/tinymist-query/src/ty/mutate.rs @@ -191,15 +191,7 @@ impl Mutator { Ty::Var(..) | Ty::Let(..) | Ty::Value(..) - | Ty::Clause - | Ty::Undef - | Ty::Content | Ty::Any - | Ty::None - | Ty::Infer - | Ty::FlowNone - | Ty::Space - | Ty::Auto | Ty::Boolean(..) | Ty::Builtin(..) => mutator.mutate(ty, pol), } diff --git a/crates/tinymist-query/src/ty/simplify.rs b/crates/tinymist-query/src/ty/simplify.rs index 34888343..0e2dd0ef 100644 --- a/crates/tinymist-query/src/ty/simplify.rs +++ b/crates/tinymist-query/src/ty/simplify.rs @@ -153,15 +153,7 @@ impl<'a, 'b> TypeSimplifier<'a, 'b> { self.analyze(&v.field, pol); } Ty::Value(_v) => {} - Ty::Clause => {} - Ty::Undef => {} - Ty::Content => {} Ty::Any => {} - Ty::None => {} - Ty::Infer => {} - Ty::FlowNone => {} - Ty::Space => {} - Ty::Auto => {} Ty::Boolean(_) => {} Ty::Builtin(_) => {} } @@ -237,15 +229,7 @@ impl<'a, 'b> TypeSimplifier<'a, 'b> { } Ty::Value(v) => Ty::Value(v.clone()), - Ty::Clause => Ty::Clause, - Ty::Undef => Ty::Undef, - Ty::Content => Ty::Content, Ty::Any => Ty::Any, - Ty::None => Ty::None, - Ty::Infer => Ty::Infer, - Ty::FlowNone => Ty::FlowNone, - Ty::Space => Ty::Space, - Ty::Auto => Ty::Auto, Ty::Boolean(b) => Ty::Boolean(*b), Ty::Builtin(b) => Ty::Builtin(b.clone()), } diff --git a/crates/tinymist-query/src/ty/subst.rs b/crates/tinymist-query/src/ty/subst.rs index 3ba7fb81..0190bb7d 100644 --- a/crates/tinymist-query/src/ty/subst.rs +++ b/crates/tinymist-query/src/ty/subst.rs @@ -71,18 +71,7 @@ impl MutateDriver for SubstituteChecker { return None; } } - Ty::Value(..) - | Ty::Clause - | Ty::Undef - | Ty::Content - | Ty::Any - | Ty::None - | Ty::Infer - | Ty::FlowNone - | Ty::Space - | Ty::Auto - | Ty::Boolean(..) - | Ty::Builtin(..) => return None, + Ty::Value(..) | Ty::Any | Ty::Boolean(..) | Ty::Builtin(..) => return None, _ => return None, }) } @@ -98,7 +87,7 @@ mod tests { #[test] fn test_ty() { use super::*; - let ty = Ty::Clause; + let ty = Ty::Builtin(BuiltinTy::Clause); let ty_ref = TyRef::new(ty.clone()); assert_debug_snapshot!(ty_ref, @"Clause"); } diff --git a/crates/tinymist-query/src/upstream/complete/ext.rs b/crates/tinymist-query/src/upstream/complete/ext.rs index aa338b86..314914b0 100644 --- a/crates/tinymist-query/src/upstream/complete/ext.rs +++ b/crates/tinymist-query/src/upstream/complete/ext.rs @@ -701,10 +701,6 @@ fn type_completion( log::info!("type_completion: {:?}", infer_type); match infer_type? { - Ty::Clause => return None, - Ty::Undef => return None, - Ty::Space => return None, - Ty::Content => return None, Ty::Any => return None, Ty::Tuple(..) | Ty::Array(..) => { ctx.snippet_completion("()", "(${})", "An array."); @@ -712,12 +708,6 @@ fn type_completion( Ty::Dict(..) => { ctx.snippet_completion("()", "(${})", "A dictionary."); } - Ty::None => ctx.snippet_completion("none", "none", "Nothing."), - Ty::Infer => return None, - Ty::FlowNone => return None, - Ty::Auto => { - ctx.snippet_completion("auto", "auto", "A smart default."); - } Ty::Boolean(_b) => { ctx.snippet_completion("false", "false", "No / Disabled."); ctx.snippet_completion("true", "true", "Yes / Enabled."); @@ -738,6 +728,17 @@ fn type_completion( }); } Ty::Builtin(v) => match v { + BuiltinTy::None => ctx.snippet_completion("none", "none", "Nothing."), + BuiltinTy::Auto => { + ctx.snippet_completion("auto", "auto", "A smart default."); + } + BuiltinTy::Clause => return None, + BuiltinTy::Undef => return None, + BuiltinTy::Space => return None, + BuiltinTy::Content => return None, + BuiltinTy::Infer => return None, + BuiltinTy::FlowNone => return None, + BuiltinTy::Path(p) => { let source = ctx.ctx.source_by_id(ctx.root.span().id()?).ok()?; @@ -852,16 +853,16 @@ fn type_completion( ctx.snippet_completion("em", "${1}em", "Em length unit."); let length_ty = Type::of::(); ctx.strict_scope_completions(false, |value| value.ty() == length_ty); - type_completion(ctx, Some(&Ty::Auto), docs); + type_completion(ctx, Some(&Ty::Builtin(BuiltinTy::Auto)), docs); } BuiltinTy::Float => { ctx.snippet_completion("exponential notation", "${1}e${0}", "Exponential notation"); } BuiltinTy::Type(ty) => { if *ty == Type::of::() { - type_completion(ctx, Some(&Ty::None), docs); + type_completion(ctx, Some(&Ty::Builtin(BuiltinTy::None)), docs); } else if *ty == Type::of::() { - type_completion(ctx, Some(&Ty::Auto), docs); + type_completion(ctx, Some(&Ty::Builtin(BuiltinTy::Auto)), docs); } else if *ty == Type::of::() { ctx.snippet_completion("false", "false", "No / Disabled."); ctx.snippet_completion("true", "true", "Yes / Enabled."); @@ -922,9 +923,9 @@ fn type_completion( if let Value::Type(ty) = &v.val { type_completion(ctx, Some(&Ty::Builtin(BuiltinTy::Type(*ty))), docs); } else if v.val.ty() == Type::of::() { - type_completion(ctx, Some(&Ty::None), docs); + type_completion(ctx, Some(&Ty::Builtin(BuiltinTy::None)), docs); } else if v.val.ty() == Type::of::() { - type_completion(ctx, Some(&Ty::Auto), docs); + type_completion(ctx, Some(&Ty::Builtin(BuiltinTy::Auto)), docs); } else { ctx.value_completion(None, &v.val, true, docs); } diff --git a/tests/e2e/main.rs b/tests/e2e/main.rs index 7bbedd4f..66dadde2 100644 --- a/tests/e2e/main.rs +++ b/tests/e2e/main.rs @@ -385,7 +385,7 @@ fn e2e() { }); let hash = replay_log(&tinymist_binary, &root.join("vscode")); - insta::assert_snapshot!(hash, @"siphash128_13:dc2b8fe3fd562e82e0ffb855267dac11"); + insta::assert_snapshot!(hash, @"siphash128_13:48f876724231ca7cdbadce094856da60"); } }