diff --git a/crates/oxc_semantic/src/builder.rs b/crates/oxc_semantic/src/builder.rs
index 83d643ef372cd..c16f5bb9bacaa 100644
--- a/crates/oxc_semantic/src/builder.rs
+++ b/crates/oxc_semantic/src/builder.rs
@@ -430,24 +430,6 @@ impl<'a> SemanticBuilder<'a> {
             self.symbols.union_flag(symbol_id, SymbolFlags::Export);
         }
     }
-
-    fn bind_function_or_class_expression(&mut self) {
-        match self.nodes.kind(self.current_node_id) {
-            AstKind::Class(class) => {
-                if class.is_expression() {
-                    // We need to bind class expression in the class scope,
-                    class.bind(self);
-                }
-            }
-            AstKind::Function(func) => {
-                if func.is_expression() {
-                    // We need to bind function expression in the function scope,
-                    func.bind(self);
-                }
-            }
-            _ => {}
-        }
-    }
 }
 
 impl<'a> Visit<'a> for SemanticBuilder<'a> {
@@ -484,10 +466,6 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
         if self.unresolved_references.len() <= self.current_scope_depth {
             self.unresolved_references.push(UnresolvedReferences::default());
         }
-
-        if !flags.is_top() {
-            self.bind_function_or_class_expression();
-        }
     }
 
     fn leave_scope(&mut self) {
@@ -570,6 +548,39 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
         self.leave_node(kind);
     }
 
+    fn visit_class(&mut self, class: &Class<'a>) {
+        let kind = AstKind::Class(self.alloc(class));
+        self.enter_node(kind);
+
+        self.visit_decorators(&class.decorators);
+        if let Some(id) = &class.id {
+            self.visit_binding_identifier(id);
+        }
+
+        self.enter_scope(ScopeFlags::StrictMode, &class.scope_id);
+        if class.is_expression() {
+            // We need to bind class expression in the class scope
+            class.bind(self);
+        }
+
+        if let Some(type_parameters) = &class.type_parameters {
+            self.visit_ts_type_parameter_declaration(type_parameters);
+        }
+        if let Some(super_class) = &class.super_class {
+            self.visit_class_heritage(super_class);
+        }
+        if let Some(super_type_parameters) = &class.super_type_parameters {
+            self.visit_ts_type_parameter_instantiation(super_type_parameters);
+        }
+        if let Some(implements) = &class.implements {
+            self.visit_ts_class_implementses(implements);
+        }
+        self.visit_class_body(&class.body);
+
+        self.leave_scope();
+        self.leave_node(kind);
+    }
+
     fn visit_continue_statement(&mut self, stmt: &ContinueStatement<'a>) {
         let kind = AstKind::ContinueStatement(self.alloc(stmt));
         self.enter_node(kind);
@@ -1458,6 +1469,11 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
             &func.scope_id,
         );
 
+        if func.is_expression() {
+            // We need to bind function expression in the function scope
+            func.bind(self);
+        }
+
         if let Some(id) = &func.id {
             self.visit_binding_identifier(id);
         }