Changes in src/AST/SymbolTable.cpp [e67991f:d76c588]

File:

• src/AST/SymbolTable.cpp (modified) (24 diffs)

src/AST/SymbolTable.cpp

@@ -73 +73 @@
 
 SymbolTable::SymbolTable()
-: idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
+: idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(), 
   prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
 
@@ -171 +171 @@
 }
 
-void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
+void SymbolTable::addDeletedId( const DeclWithType * decl, const Node * deleter ) {
         // default handling of conflicts is to raise an error
         addId( decl, OnConflict::error(), nullptr, deleter );
@@ -189 +189 @@
                         }
                 }
-                // does not need to be added to the table if both existing and added have a base that are
+                // does not need to be added to the table if both existing and added have a base that are 
                 // the same
                 return true;
@@ -209 +209 @@
         const std::string &id = decl->name;
 
-        if ( ! typeTable ) {
+        if ( ! typeTable ) { 
                 typeTable = TypeTable::new_ptr();
         } else {
                 ++*stats().map_lookups;
                 auto existing = typeTable->find( id );
-                if ( existing != typeTable->end()
-                        && existing->second.scope == scope
+                if ( existing != typeTable->end() 
+                        && existing->second.scope == scope 
                         && addedTypeConflicts( existing->second.decl, decl ) ) return;
         }
-
+        
         lazyInitScope();
         ++*stats().map_mutations;
@@ -237 +237 @@
                 ++*stats().map_lookups;
                 auto existing = structTable->find( id );
-                if ( existing != structTable->end()
-                        && existing->second.scope == scope
+                if ( existing != structTable->end()  
+                        && existing->second.scope == scope 
                         && addedDeclConflicts( existing->second.decl, decl ) ) return;
         }
@@ -256 +256 @@
                 ++*stats().map_lookups;
                 auto existing = enumTable->find( id );
-                if ( existing != enumTable->end()
-                        && existing->second.scope == scope
+                if ( existing != enumTable->end()  
+                        && existing->second.scope == scope 
                         && addedDeclConflicts( existing->second.decl, decl ) ) return;
         }
-
+        
         lazyInitScope();
         ++*stats().map_mutations;
@@ -279 +279 @@
                 ++*stats().map_lookups;
                 auto existing = unionTable->find( id );
-                if ( existing != unionTable->end()
-                        && existing->second.scope == scope
+                if ( existing != unionTable->end() 
+                        && existing->second.scope == scope 
                         && addedDeclConflicts( existing->second.decl, decl ) ) return;
         }
@@ -298 +298 @@
                 ++*stats().map_lookups;
                 auto existing = traitTable->find( id );
-                if ( existing != traitTable->end()
-                        && existing->second.scope == scope
+                if ( existing != traitTable->end() 
+                        && existing->second.scope == scope 
                         && addedDeclConflicts( existing->second.decl, decl ) ) return;
         }
@@ -309 +309 @@
 
 
-void SymbolTable::addWith( const std::vector< ptr<Expr> > & withExprs, const Decl * withStmt ) {
+void SymbolTable::addWith( const std::vector< ptr<Expr> > & withExprs, const Node * withStmt ) {
         for ( const Expr * expr : withExprs ) {
                 if ( ! expr->result ) continue;
                 const Type * resTy = expr->result->stripReferences();
                 auto aggrType = dynamic_cast< const ReferenceToType * >( resTy );
-                assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
+                assertf( aggrType, "WithStmt expr has non-aggregate type: %s", 
                         toString( expr->result ).c_str() );
                 const AggregateDecl * aggr = aggrType->aggr();
-                assertf( aggr, "WithStmt has null aggregate from type: %s",
+                assertf( aggr, "WithStmt has null aggregate from type: %s", 
                         toString( expr->result ).c_str() );
-
+                
                 addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
         }
@@ -373 +373 @@
         }
 
-        /// gets the declaration for the function acting on a type specified by otype key,
+        /// gets the declaration for the function acting on a type specified by otype key, 
         /// nullptr if none such
-        const FunctionDecl * getFunctionForOtype(
+        const FunctionDecl * getFunctionForOtype( 
                         const DeclWithType * decl, const std::string & otypeKey ) {
                 auto func = dynamic_cast< const FunctionDecl * >( decl );
@@ -383 +383 @@
 }
 
-bool SymbolTable::removeSpecialOverrides(
+bool SymbolTable::removeSpecialOverrides( 
                 SymbolTable::IdData & data, SymbolTable::MangleTable::Ptr & mangleTable ) {
-        // if a type contains user defined ctor/dtor/assign, then special rules trigger, which
-        // determine the set of ctor/dtor/assign that can be used  by the requester. In particular,
-        // if the user defines a default ctor, then the generated default ctor is unavailable,
-        // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated
-        // field ctors are available. If the user defines any ctor then the generated default ctor
-        // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines
-        // anything that looks like a copy constructor, then the generated copy constructor is
+        // if a type contains user defined ctor/dtor/assign, then special rules trigger, which 
+        // determine the set of ctor/dtor/assign that can be used  by the requester. In particular, 
+        // if the user defines a default ctor, then the generated default ctor is unavailable, 
+        // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated 
+        // field ctors are available. If the user defines any ctor then the generated default ctor 
+        // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines 
+        // anything that looks like a copy constructor, then the generated copy constructor is 
         // unavailable, and likewise for the assignment operator.
 
@@ -450 +450 @@
                 // if this is the first user-defined function, delete non-user-defined overloads
                 std::vector< MangleTable::value_type > deleted;
-
+                
                 for ( const auto& entry : *mangleTable ) {
                         // skip decls that aren't functions or are for the wrong type
@@ -489 +489 @@
                         if ( dataIsCopyFunc ) {
                                 // remove current function if exists a user-defined copy function
-                                // since the signatures for copy functions don't need to match exactly, using
+                                // since the signatures for copy functions don't need to match exactly, using 
                                 // a delete statement is the wrong approach
                                 if ( InitTweak::isCopyFunction( decl ) ) return false;
@@ -499 +499 @@
                 }
         }
-
+        
         // nothing (more) to fix, return true
         return true;
@@ -525 +525 @@
 
 bool SymbolTable::addedIdConflicts(
-                const SymbolTable::IdData & existing, const DeclWithType * added,
-                SymbolTable::OnConflict handleConflicts, const Decl * deleter ) {
-        // if we're giving the same name mangling to things of different types then there is something
+                const SymbolTable::IdData & existing, const DeclWithType * added, 
+                SymbolTable::OnConflict handleConflicts, const Node * deleter ) {
+        // if we're giving the same name mangling to things of different types then there is something 
         // wrong
         assert( (isObject( added ) && isObject( existing.id ) )
                 || ( isFunction( added ) && isFunction( existing.id ) ) );
-
+        
         if ( existing.id->linkage.is_overrideable ) {
                 // new definition shadows the autogenerated one, even at the same scope
                 return false;
-        } else if ( existing.id->linkage.is_mangled
-                        || ResolvExpr::typesCompatible(
+        } else if ( existing.id->linkage.is_mangled 
+                        || ResolvExpr::typesCompatible( 
                                 added->get_type(), existing.id->get_type(), SymbolTable{} ) ) {
-
+                
                 // it is a conflict if one declaration is deleted and the other is not
                 if ( deleter && ! existing.deleter ) {
@@ -555 +555 @@
                 if ( isDefinition( added ) && isDefinition( existing.id ) ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added,
-                                        isFunction( added ) ?
-                                                "duplicate function definition for " :
+                                SemanticError( added, 
+                                        isFunction( added ) ? 
+                                                "duplicate function definition for " : 
                                                 "duplicate object definition for " );
                         }
@@ -572 +572 @@
 }
 
-void SymbolTable::addId(
-                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
+void SymbolTable::addId( 
+                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr, 
+                const Node * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -581 +581 @@
         std::string mangleName;
         if ( decl->linkage.is_overrideable ) {
-                // mangle the name without including the appropriate suffix, so overridable routines
+                // mangle the name without including the appropriate suffix, so overridable routines 
                 // are placed into the same "bucket" as their user defined versions.
                 mangleName = Mangle::mangle( decl, Mangle::Mode{ Mangle::NoOverrideable } );
@@ -588 +588 @@
         }
 
-        // this ensures that no two declarations with the same unmangled name at the same scope
+        // this ensures that no two declarations with the same unmangled name at the same scope 
         // both have C linkage
         if ( decl->linkage.is_mangled ) {
@@ -596 +596 @@
                 }
         } else {
-                // NOTE: only correct if name mangling is completely isomorphic to C
+                // NOTE: only correct if name mangling is completely isomorphic to C 
                 // type-compatibility, which it may not be.
                 if ( hasIncompatibleCDecl( name, mangleName ) ) {
@@ -628 +628 @@
                                                 idTable = idTable->set(
                                                         name,
-                                                        mangleTable->set(
-                                                                mangleName,
+                                                        mangleTable->set( 
+                                                                mangleName, 
                                                                 IdData{ existing->second, handleConflicts.deleter } ) );
                                         }
@@ -647 +647 @@
 }
 
-void SymbolTable::addMembers(
+void SymbolTable::addMembers( 
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
         for ( const Decl * decl : aggr->members ) {
@@ -655 +655 @@
                                 const Type * t = dwt->get_type()->stripReferences();
                                 if ( auto rty = dynamic_cast<const ReferenceToType *>( t ) ) {
-                                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                        if ( ! dynamic_cast<const StructInstType *>(rty) 
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
                                         ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
                                         const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
-                                        addMembers(
+                                        addMembers( 
                                                 rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
                                 }
@@ -680 +680 @@
                 if ( ! decl.second.id->linkage.is_mangled && decl.first == mangleName ) return true;
         }
-
+        
         return false;
 }