Changes in src/Virtual/ExpandCasts.cc [f19fbbc:c19bc90]

File:

• src/Virtual/ExpandCasts.cc (modified) (9 diffs)

src/Virtual/ExpandCasts.cc

@@ -10 +10 @@
 // Created On       : Mon Jul 24 13:59:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Jul 22 10:04:00 2020
-// Update Count     : 3
+// Last Modified On : Tue May 26 14:37:00 2020
+// Update Count     : 2
 //
 
@@ -24 +24 @@
 #include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/SemanticError.h"  // for SemanticError
-#include "SymTab/Mangler.h"        // for mangleType
 #include "SynTree/Declaration.h"   // for ObjectDecl, StructDecl, FunctionDecl
 #include "SynTree/Expression.h"    // for VirtualCastExpr, CastExpr, Address...
@@ -33 +32 @@
 namespace Virtual {
 
-        // Indented until the new ast code gets added.
-
-        /// Maps virtual table types the instance for that type.
-        class VirtualTableMap final {
-                std::unordered_map<std::string, ObjectDecl *> vtable_instances;
-        public:
-                ObjectDecl * insert( ObjectDecl * vtableDecl ) {
-                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableDecl->type );
-                        ObjectDecl *& value = vtable_instances[ mangledName ];
-                        if ( value ) {
-                                if ( vtableDecl->storageClasses.is_extern ) {
-                                        return nullptr;
-                                } else if ( ! value->storageClasses.is_extern ) {
-                                        return value;
-                                }
-                        }
-                        value = vtableDecl;
-                        return nullptr;
-                }
-
-                ObjectDecl * lookup( const Type * vtableType ) {
-                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableType );
-                        const auto it = vtable_instances.find( mangledName );
-                        return ( vtable_instances.end() == it ) ? nullptr : it->second;
-                }
-        };
-
         /* Currently virtual depends on the rather brittle name matching between
          * a (strict/explicate) virtual type, its vtable type and the vtable
@@ -66 +38 @@
          * and use that information to create better error messages.
          */
-
-        namespace {
 
         std::string get_vtable_name( std::string const & name ) {
@@ -85 +55 @@
         }
 
+        bool is_vtable_name( std::string const & name ) {
+                return (name.substr( name.size() - 7 ) == "_vtable" );
+        }
+
         bool is_vtable_inst_name( std::string const & name ) {
                 return 17 < name.size() &&
@@ -90 +64 @@
         }
 
-        } // namespace
-
         class VirtualCastCore {
-                VirtualTableMap vtable_instances;
-                FunctionDecl *vcast_decl;
-                StructDecl *pvt_decl;
+        std::map<std::string, ObjectDecl *> vtable_instances;
+        FunctionDecl *vcast_decl;
+        StructDecl *pvt_decl;
 
                 Type * pointer_to_pvt(int level_of_indirection) {
@@ -135 +107 @@
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
                 if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
-                        if ( ObjectDecl * existing = vtable_instances.insert( objectDecl ) ) {
-                                std::string msg = "Repeated instance of virtual table, original found at: ";
-                                msg += existing->location.filename;
-                                msg += ":" + toString( existing->location.first_line );
-                                SemanticError( objectDecl->location, msg );
-                        }
+                        vtable_instances[objectDecl->get_name()] = objectDecl;
                 }
         }
 
-        namespace {
-
-        /// Better error locations for generated casts.
-        CodeLocation castLocation( const VirtualCastExpr * castExpr ) {
+        // Better error locations for generated casts.
+        static CodeLocation castLocation( VirtualCastExpr * castExpr ) {
                 if ( castExpr->location.isSet() ) {
                         return castExpr->location;
@@ -159 +124 @@
         }
 
-        [[noreturn]] void castError( const VirtualCastExpr * castExpr, std::string const & message ) {
-                SemanticError( castLocation( castExpr ), message );
-        }
-
-        /// Get the virtual table type used in a virtual cast.
-        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
-                const Type * objectType;
-                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
-                        objectType = target->base;
-                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
-                        objectType = target->base;
-                } else {
-                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
-                }
-                assert( objectType );
-
-                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
-                if ( nullptr == structType ) {
-                        castError( castExpr, "Virtual cast type must refer to a structure type." );
-                }
-                const StructDecl * structDecl = structType->baseStruct;
-                assert( structDecl );
-
-                const ObjectDecl * fieldDecl = nullptr;
-                if ( 0 < structDecl->members.size() ) {
-                        const Declaration * memberDecl = structDecl->members.front();
-                        assert( memberDecl );
-                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
-                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
-                                fieldDecl = nullptr;
-                        }
-                }
-                if ( nullptr == fieldDecl ) {
-                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
-                }
-                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
-                if ( nullptr == fieldType ) {
-                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
-                }
-                assert( fieldType->base );
-                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
-                assert( virtualStructType );
-
-                // Here is the type, but if it is polymorphic it will have lost information.
-                // (Always a clone so that it may always be deleted.)
-                StructInstType * virtualType = virtualStructType->clone();
-                if ( ! structType->parameters.empty() ) {
-                        deleteAll( virtualType->parameters );
-                        virtualType->parameters.clear();
-                        cloneAll( structType->parameters, virtualType->parameters );
-                }
-                return virtualType;
-        }
-
-        } // namespace
-
         Expression * VirtualCastCore::postmutate( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->result, "Virtual Cast target not found before expansion." );
+                assertf( castExpr->get_result(), "Virtual Cast target not found before expansion." );
 
                 assert( vcast_decl );
                 assert( pvt_decl );
 
-                const Type * vtable_type = getVirtualTableType( castExpr );
-                ObjectDecl * table = vtable_instances.lookup( vtable_type );
-                if ( nullptr == table ) {
+                // Get the base type of the pointer/reference.
+                Type * base;
+                Type * result_type = castExpr->result;
+                if ( PointerType * target = dynamic_cast<PointerType *>( result_type ) ) {
+                        base = target->base;
+                } else if ( ReferenceType * target = dynamic_cast<ReferenceType *>( result_type ) ) {
+                        base = target->base;
+                } else {
                         SemanticError( castLocation( castExpr ),
-                                "Could not find virtual table instance." );
+                                "Virtual cast type must be a pointer or reference type." );
                 }
+
+                StructInstType * target_struct = dynamic_cast<StructInstType *>( base );
+                if ( nullptr == target_struct ) {
+                        SemanticError( castLocation( castExpr ),
+                                "Virtual cast type must refer to a structure type." );
+                }
+                StructDecl * target_decl = target_struct->get_baseStruct();
+
+                std::map<std::string, ObjectDecl *>::iterator found =
+                        vtable_instances.find( get_vtable_inst_name( target_decl->get_name() ) );
+                if ( vtable_instances.end() == found ) {
+                        SemanticError( castLocation( castExpr ),
+                                "Virtual cast type does not have a virtual table instance." );
+                }
+                ObjectDecl * table = found->second;
 
                 Expression * result = new CastExpr(
@@ -245 +174 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
-                delete vtable_type;
                 return result;
         }