Automatically promote constants to namespaces

Author: vinistock

rust/rubydex/src/model/declaration.rs

@@ -123,11 +123,14 @@ macro_rules! namespace_declaration {
                 }
             }
 
-            pub fn extend(&mut self, mut other: Namespace) {
+            pub fn extend(&mut self, mut other: Declaration) {
                 self.definition_ids.extend(other.definitions());
                 self.references.extend(other.references());
-                self.members.extend(other.members());
                 self.diagnostics.extend(other.take_diagnostics());
+
+                if let Declaration::Namespace(namespace) = other {
+                    self.members.extend(namespace.members());
+                }
             }
 
             pub fn set_singleton_class_id(&mut self, declaration_id: DeclarationId) {
@@ -408,6 +411,10 @@ impl Namespace {
         all_namespaces!(self, it => std::mem::take(&mut it.diagnostics))
     }
 
+    pub fn extend(&mut self, other: Declaration) {
+        all_namespaces!(self, it => it.extend(other));
+    }
+
     /// # Panics
     ///
     /// Panics if the declaration is not a namespace or a constant
@@ -468,6 +475,11 @@ impl Namespace {
     pub fn set_singleton_class_id(&mut self, declaration_id: DeclarationId) {
         all_namespaces!(self, it => it.set_singleton_class_id(declaration_id));
     }
+
+    #[must_use]
+    pub fn name(&self) -> &str {
+        all_namespaces!(self, it => &it.name)
+    }
 }
 
 namespace_declaration!(Class, ClassDeclaration);

rust/rubydex/src/model/graph.rs

@@ -81,8 +81,32 @@ impl Graph {
     {
         self.definitions_to_declarations.insert(definition_id, declaration_id);
 
-        let declaration = self.declarations.entry(declaration_id).or_insert_with(constructor);
-        declaration.add_definition(definition_id);
+        match self.declarations.entry(declaration_id) {
+            Entry::Occupied(mut occupied_entry) => {
+                // If we already have a declaration created, we need to check if it needs to be promoted. For example,
+                // if we thought this declaration was a constant due to meta-programming and then it gets re-opened with
+                // the `class` keyword, then we must promote it to a class
+                if matches!(occupied_entry.get(), Declaration::Constant(_))
+                    && matches!(
+                        self.definitions.get(&definition_id).unwrap(),
+                        Definition::Class(_) | Definition::Module(_) | Definition::SingletonClass(_)
+                    )
+                {
+                    let mut new_declaration = constructor();
+                    let removed_declaration = occupied_entry.remove();
+                    new_declaration.as_namespace_mut().unwrap().extend(removed_declaration);
+                    new_declaration.add_definition(definition_id);
+                    self.declarations.insert(declaration_id, new_declaration);
+                } else {
+                    occupied_entry.get_mut().add_definition(definition_id);
+                }
+            }
+            Entry::Vacant(vacant_entry) => {
+                let mut declaration = constructor();
+                declaration.add_definition(definition_id);
+                vacant_entry.insert(declaration);
+            }
+        }
     }
 
     /// # Panics
@@ -382,9 +406,6 @@ impl Graph {
                 Declaration::Namespace(Namespace::SingletonClass(it)) => {
                     it.add_member(member_str_id, member_declaration_id);
                 }
-                Declaration::Constant(_) => {
-                    // TODO: temporary hack to avoid crashing on `Struct.new`, `Class.new` and `Module.new`
-                }
                 _ => panic!("Tried to add member to a declaration that isn't a namespace"),
             }
         }