Changes in src/Concurrency/Keywords.cc [8edbe40:43cedfb1]

File:

• src/Concurrency/Keywords.cc (modified) (10 diffs)

src/Concurrency/Keywords.cc

@@ -42 +42 @@
 
 namespace Concurrency {
-        inline static std::string getTypeIdName( std::string const & exception_name ) {
-                return exception_name.empty() ? std::string() : Virtual::typeIdType( exception_name );
-        }
         inline static std::string getVTableName( std::string const & exception_name ) {
-                return exception_name.empty() ? std::string() : Virtual::vtableTypeName( exception_name );
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
         }
 
@@ -78 +75 @@
                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
                   context_error( context_error ), exception_name( exception_name ),
-                  typeid_name( getTypeIdName( exception_name ) ),
                   vtable_name( getVTableName( exception_name ) ),
                   needs_main( needs_main ), cast_target( cast_target ) {}
@@ -88 +84 @@
 
                 void handle( StructDecl * );
-                void addTypeId( StructDecl * );
                 void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
@@ -104 +99 @@
                 const std::string context_error;
                 const std::string exception_name;
-                const std::string typeid_name;
                 const std::string vtable_name;
                 bool needs_main;
@@ -112 +106 @@
                 FunctionDecl * dtor_decl = nullptr;
                 StructDecl * except_decl = nullptr;
-                StructDecl * typeid_decl = nullptr;
                 StructDecl * vtable_decl = nullptr;
         };
@@ -400 +393 @@
                         except_decl = decl;
                 }
-                else if ( !typeid_decl && typeid_name == decl->name && decl->body ) {
-                        typeid_decl = decl;
-                }
                 else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
                         vtable_decl = decl;
@@ -414 +404 @@
                 if ( type_decl && isDestructorFor( decl, type_decl ) )
                         dtor_decl = decl;
-                else if ( vtable_name.empty() || !decl->has_body() )
+                else if ( vtable_name.empty() )
+                        ;
+                else if( !decl->has_body() )
                         ;
                 else if ( auto param = isMainFor( decl, cast_target ) ) {
@@ -426 +418 @@
                         std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
                         ObjectDecl * vtable_object = Virtual::makeVtableInstance(
-                                "_default_vtable_object_declaration",
                                 vtable_decl->makeInst( poly_args ), struct_type, nullptr );
                         declsToAddAfter.push_back( vtable_object );
-                        declsToAddAfter.push_back(
-                                new ObjectDecl(
-                                        Virtual::concurrentDefaultVTableName(),
-                                        Type::Const,
-                                        LinkageSpec::Cforall,
-                                        /* bitfieldWidth */ nullptr,
-                                        new ReferenceType( Type::Const, vtable_object->type->clone() ),
-                                        new SingleInit( new VariableExpr( vtable_object ) )
-                                )
-                        );
                         declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
                                 vtable_object, except_decl->makeInst( std::move( poly_args ) )
@@ -467 +448 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
-                if ( !exception_name.empty() ) {
-                        if( !typeid_decl ) SemanticError( decl, context_error );
-                        if( !vtable_decl ) SemanticError( decl, context_error );
-
-                        addTypeId( decl );
-                        addVtableForward( decl );
-                }
+                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
@@ -479 +454 @@
         }
 
-        void ConcurrentSueKeyword::addTypeId( StructDecl * decl ) {
-                assert( typeid_decl );
-                StructInstType typeid_type( Type::Const, typeid_decl );
-                typeid_type.parameters.push_back( new TypeExpr(
-                        new StructInstType( noQualifiers, decl )
+        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        std::list< Expression * > poly_args = {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        };
+                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                                vtable_decl->makeInst( poly_args ),
+                                except_decl->makeInst( poly_args )
                         ) );
-                declsToAddBefore.push_back( Virtual::makeTypeIdInstance( &typeid_type ) );
-        }
-
-        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
-                assert( vtable_decl );
-                std::list< Expression * > poly_args = {
-                        new TypeExpr( new StructInstType( noQualifiers, decl ) ),
-                };
-                declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
-                        vtable_decl->makeInst( poly_args ),
-                        except_decl->makeInst( poly_args )
-                ) );
-                ObjectDecl * vtable_object = Virtual::makeVtableForward(
-                        "_default_vtable_object_declaration",
-                        vtable_decl->makeInst( move( poly_args ) ) );
-                declsToAddBefore.push_back( vtable_object );
-                declsToAddBefore.push_back(
-                        new ObjectDecl(
-                                Virtual::concurrentDefaultVTableName(),
-                                Type::Const,
-                                LinkageSpec::Cforall,
-                                /* bitfieldWidth */ nullptr,
-                                new ReferenceType( Type::Const, vtable_object->type->clone() ),
-                                /* init */ nullptr
-                        )
-                );
+                        declsToAddBefore.push_back( Virtual::makeVtableForward(
+                                vtable_decl->makeInst( move( poly_args ) ) ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
         }