Changeset 64f3b9f

Timestamp:

Dec 11, 2024, 6:09:10 PM (6 days ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

e797179

Parents:

ec22220

Message:

Fix support for partial autogen.

Partial autogen means that some lifecycle functions are possible to generate, and needed, while others are impossible to generate, but unneeded. It is a valid situation that a user can implicitly request.

Previous handling of "impossible to generate" left the function in a zombie state, where it could show up as an alternative later. This zombie state is problematic handling caused by a compiler bug. Without the fix, the added test fails by creating zombie states.

This change is also a prerequsite for an upcoming change to avoid gcc warnings by not emitting autogen forward declarations.

Files:

• src/AST/SymbolTable.cpp (modified) (1 diff)
• src/AST/SymbolTable.hpp (modified) (1 diff)
• src/ResolvExpr/Resolver.cpp (modified) (1 diff)
• tests/Makefile.am (modified) (1 diff)
• tests/raii/.expect/partial-ERR1.txt (added)
• tests/raii/.expect/partial.txt (added)
• tests/raii/partial.cfa (added)

src/AST/SymbolTable.cpp

@@ -522 +522 @@
 }
 
+void SymbolTable::reviseSpecialAsDeleted( const FunctionDecl * func ) {
+        SpecialFunctionKind kind = getSpecialFunctionKind(func->name);
+        assert( kind != NUMBER_OF_KINDS );
+        assert( func->linkage.is_overrideable );
+        IdTable::Ptr & idTable = specialFunctionTable[kind];
+
+        std::string otypeKey = getOtypeKey(func->type);
+        IdTable::iterator idHit = idTable->find( otypeKey );
+        assert( idHit != idTable->end() );
+        MangleTable::Ptr mangleTable = idHit->second;
+
+        std::string mangleName = Mangle::mangle( func, Mangle::Mode{ Mangle::NoOverrideable } );
+        MangleTable::iterator mangleHit = mangleTable->find( mangleName );
+        assert( mangleHit != mangleTable->end() );
+        IdData oldEntry = mangleHit->second;
+        assert( oldEntry.id == func );
+
+        mangleTable = mangleTable->set( mangleName, oldEntry.withDeleter( func ) );
+        idTable = idTable->set( otypeKey, mangleTable );
+}
+
 bool SymbolTable::removeSpecialOverrides(
                 SymbolTable::IdData & data, SymbolTable::MangleTable::Ptr & mangleTable ) {

src/AST/SymbolTable.hpp

@@ -177 +177 @@
         void addFunction( const FunctionDecl * );
 
+        /// Reclassifies the previously-indexed special declaration, so `combine` shows it as deleted
+        void reviseSpecialAsDeleted( const FunctionDecl * );
+
 private:
         void OnFindError( CodeLocation location, std::string error ) const;

src/ResolvExpr/Resolver.cpp

@@ -1331 +1331 @@
                         mutDecl->isDeleted = true;
                         mutDecl->stmts = nullptr;
+                        symtab.reviseSpecialAsDeleted( functionDecl );
                         decl = mutDecl;
                         return false;

tests/Makefile.am

@@ -272 +272 @@
         -cp ${test} ${abspath ${@}}
 
+raii/partial-ERR1 : raii/partial.cfa ${CFACCBIN}
+        ${CFACOMPILE_SYNTAX} -DERR1
+        -cp ${test} ${abspath ${@}}
+
 # Exception Tests
 # Test with libcfathread; it changes how storage works.