check invalid compute prop name

Author: bvanjoi

Cargo.lock

@@ -14,6 +14,7 @@ members = [
   "crates/middle",
   "crates/module_graph",
   "crates/module_resolve",
+  "crates/napi",
   "crates/optimize",
   "crates/parser",
   "crates/path",

Cargo.toml

@@ -112,6 +112,14 @@ impl<'cx> Expr<'cx> {
         )
     }
 
+    pub fn is_signed_numeric_lit(&self) -> bool {
+        let ExprKind::PrefixUnary(n) = &self.kind else {
+            return false;
+        };
+        matches!(n.op, PrefixUnaryOp::Plus | PrefixUnaryOp::Minus)
+            && matches!(n.expr.kind, ExprKind::NumLit(_))
+    }
+
     pub fn is_string_or_number_lit_like(&self) -> bool {
         self.is_string_lit_like() || matches!(self.kind, ExprKind::NumLit(_))
     }

crates/ast/src/expr.rs

@@ -72,7 +72,9 @@ impl<'cx> DeclarationName<'cx> {
     pub fn is_dynamic_name(&self) -> bool {
         use DeclarationName::*;
         match self {
-            Computed(_) => true,
+            Computed(n) => {
+                !n.expr.is_string_or_number_lit_like() && !n.expr.is_signed_numeric_lit()
+            }
             // TODO: element access
             _ => false,
         }

crates/ast/src/lib.rs

@@ -18,8 +18,8 @@ pub fn print_declaration_name(node: &super::DeclarationName, atoms: &AtomIntern)
 pub fn pprint_binding(binding: &super::Binding<'_>, atoms: &AtomIntern) -> String {
     match binding.kind {
         super::BindingKind::Ident(ident) => pprint_ident(ident, atoms),
-        super::BindingKind::ObjectPat(n) => todo!(),
-        crate::BindingKind::ArrayPat(n) => todo!(),
+        super::BindingKind::ObjectPat(_) => todo!(),
+        super::BindingKind::ArrayPat(_) => todo!(),
     }
 }
 

crates/ast/src/pprint.rs

@@ -1,7 +1,7 @@
 use super::symbol_info::SymbolInfo;
+use super::ty;
+use super::ty::TypeFlags;
 use super::{TyChecker, errors};
-use crate::ty;
-use crate::ty::TypeFlags;
 
 use bolt_ts_ast::r#trait::ClassLike;
 use bolt_ts_ast::{self as ast, pprint_ident};
@@ -100,7 +100,33 @@ impl<'cx> TyChecker<'cx> {
         self.check_fn_like_decl(method);
     }
 
+    pub(super) fn check_invalid_dynamic_name(
+        &mut self,
+        name: ast::DeclarationName<'cx>,
+        push_error: impl FnOnce(&mut Self),
+    ) {
+        if !self.is_non_bindable_dynamic_name(&name) {
+            return;
+        }
+        let expr = match name {
+            ast::DeclarationName::Computed(n) => n.expr,
+            // TODO: element access expr
+            _ => unreachable!(),
+        };
+        if !expr.is_entity_name_expr() {
+            push_error(self);
+        }
+    }
+
     fn check_class_prop_ele(&mut self, prop: &'cx ast::ClassPropElem<'cx>) {
+        let decl_name = ast::DeclarationName::from_prop_name(prop.name);
+        self.check_invalid_dynamic_name(decl_name, |this| {
+            let error = errors::AComputedPropertyNameInAClassPropertyDeclarationMustHaveASimpleLiteralTypeOrAUniqueSymbolType {
+                span: prop.name.span(),
+            };
+            this.push_error(Box::new(error));
+        });
+
         self.check_var_like_decl(prop);
     }
 

crates/checker/src/check/check_class_decl_like.rs

@@ -1,11 +1,10 @@
 use bolt_ts_ast as ast;
 
-use crate::check::errors;
-use crate::check::relation::RelationKind;
-use crate::check::symbol_info::SymbolInfo;
-
 use super::NodeCheckFlags;
 use super::TyChecker;
+use super::errors;
+use super::relation::RelationKind;
+use super::symbol_info::SymbolInfo;
 
 impl<'cx> TyChecker<'cx> {
     pub(super) fn check_node_deferred(&mut self, node: ast::NodeID) {

crates/checker/src/check/check_deferred.rs

@@ -61,7 +61,16 @@ impl<'cx> TyChecker<'cx> {
 
     fn check_object_ty_member(&mut self, member: &'cx ast::ObjectTyMember<'cx>) {
         match member.kind {
-            ast::ObjectTyMemberKind::Prop(n) => self.check_var_like_decl(n),
+            ast::ObjectTyMemberKind::Prop(n) => {
+                let decl_name = ast::DeclarationName::from_prop_name(n.name);
+                self.check_invalid_dynamic_name(decl_name, |this| {
+                    let error = errors::AComputedPropertyNameInAnInterfaceMustReferToAnExpressionWhoseTypeIsALiteralTypeOrAUniqueSymbolType {
+                        span: n.name.span(),
+                    };
+                    this.push_error(Box::new(error));
+                });
+                self.check_var_like_decl(n)
+            }
             _ => {
                 // TODO:
             }

crates/checker/src/check/check_interface.rs

@@ -1099,3 +1099,23 @@ pub(super) struct RestTypesMayOnlyBeCreatedFromObjectTypes {
     #[label(primary)]
     pub span: Span,
 }
+
+#[derive(Error, Diagnostic, Debug, DiagnosticExt, Default)]
+#[error(
+    "A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type."
+)]
+pub(super) struct AComputedPropertyNameInAClassPropertyDeclarationMustHaveASimpleLiteralTypeOrAUniqueSymbolType
+{
+    #[label(primary)]
+    pub span: Span,
+}
+
+#[derive(Error, Diagnostic, Debug, DiagnosticExt, Default)]
+#[error(
+    "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."
+)]
+pub(super) struct AComputedPropertyNameInAnInterfaceMustReferToAnExpressionWhoseTypeIsALiteralTypeOrAUniqueSymbolType
+{
+    #[label(primary)]
+    pub span: Span,
+}

crates/checker/src/check/errors.rs

@@ -1,5 +1,4 @@
 use std::cell::OnceCell;
-use std::ptr::read_unaligned;
 
 use super::FlowLoopTypesArenaId;
 use super::TyChecker;