syntax update: the default value of ConstParam turned from Expr into ConstArg

Author: ponyii

crates/hir-def/src/generics.rs

@@ -248,7 +248,7 @@ impl GenericParams {
                     let param = ConstParamData {
                         name,
                         ty: Interned::new(ty),
-                        default: ConstRef::from_default_param_value(lower_ctx, const_param),
+                        default: ConstRef::from_const_param(lower_ctx, const_param),
                     };
                     self.type_or_consts.alloc(param.into());
                 }

crates/hir-def/src/hir/type_ref.rs

@@ -393,15 +393,12 @@ impl ConstRef {
         Self::Scalar(LiteralConstRef::Unknown)
     }
 
-    pub(crate) fn from_default_param_value(
-        _: &LowerCtx<'_>,
-        param: ast::ConstParam,
-    ) -> Option<Self> {
-        if let Some(expr) = param.default_val() {
-            // FIXME: pass the `ast_id` arg to recognize complex expressions
-            return Some(Self::from_expr(expr, None));
+    pub(crate) fn from_const_param(lower_ctx: &LowerCtx<'_>, param: ast::ConstParam) -> Option<Self> {
+        let default = param.default_val();
+        match default {
+            Some(_) => Some(Self::from_const_arg(lower_ctx, default)),
+            None => None
         }
-        None
     }
 
     pub fn display<'a>(&'a self, db: &'a dyn ExpandDatabase) -> impl fmt::Display + 'a {

crates/hir-ty/src/lib.rs

@@ -716,6 +716,10 @@ where
 
 pub fn known_const_to_string(konst: &Const, db: &dyn HirDatabase) -> Option<String> {
     if let ConstValue::Concrete(c) = &konst.interned().value {
+        if let ConstScalar::UnevaluatedConst(_, _) = &c.interned {
+            // FIXME: stringify the block expression
+            return None;
+        }
         if c.interned == ConstScalar::Unknown {
             return None;
         }

crates/ide-assists/src/handlers/extract_function.rs

@@ -810,7 +810,7 @@ impl FunctionBody {
                         (true, konst.body(), Some(sema.to_def(&konst)?.ty(sema.db)))
                     },
                     ast::ConstParam(cp) => {
-                        (true, cp.default_val(), Some(sema.to_def(&cp)?.ty(sema.db)))
+                        (true, cp.default_val()?.expr(), Some(sema.to_def(&cp)?.ty(sema.db)))
                     },
                     ast::ConstBlockPat(cbp) => {
                         let expr = cbp.block_expr().map(ast::Expr::BlockExpr);

crates/ide-db/src/path_transform.rs

@@ -160,9 +160,10 @@ impl<'a> PathTransform<'a> {
                 }
                 (Either::Left(k), None) => {
                     if let Some(default) = k.default(db) {
-                        let default = ast::make::expr_const_value(&default);
-                        const_substs.insert(k, default.syntax().clone_for_update());
-                        // FIXME: transform the default value
+                        if let Some(default) = ast::make::expr_const_value(&default).expr() {
+                            const_substs.insert(k, default.syntax().clone_for_update());
+                            // FIXME: transform the default value
+                        }
                     }
                 }
                 _ => (), // ignore mismatching params

crates/parser/src/grammar/generic_params.rs

@@ -89,7 +89,7 @@ fn const_param(p: &mut Parser<'_>, m: Marker) {
 
         // test const_param_default_path
         // struct A<const N: i32 = i32::MAX>;
-        generic_args::const_arg_expr(p);
+        generic_args::const_arg(p);
     }
 
     m.complete(p, CONST_PARAM);

crates/syntax/rust.ungram

@@ -290,7 +290,7 @@ TypeParam =
 
 ConstParam =
   Attr* 'const' Name ':' Type
-  ('=' default_val:Expr)?
+  ('=' default_val:ConstArg)?
 
 LifetimeParam =
   Attr* Lifetime (':' TypeBoundList?)?

crates/syntax/src/ast/generated/nodes.rs

@@ -695,7 +695,7 @@ impl ConstParam {
     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]

crates/syntax/src/ast/make.rs

@@ -507,7 +507,7 @@ pub fn expr_literal(text: &str) -> ast::Literal {
     ast_from_text(&format!("fn f() {{ let _ = {text}; }}"))
 }
 
-pub fn expr_const_value(text: &str) -> ast::Expr {
+pub fn expr_const_value(text: &str) -> ast::ConstArg {
     ast_from_text(&format!("trait Foo<const N: usize = {text}> {{}}"))
 }