Changes in src/AST/SymbolTable.cpp [251ce80:4b8b2a4]

File:

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

src/AST/SymbolTable.cpp

@@ -18 +18 @@
 #include <cassert>
 
-#include "Copy.hpp"
 #include "Decl.hpp"
 #include "Expr.hpp"
 #include "Inspect.hpp"
 #include "Type.hpp"
-#include "CodeGen/OperatorTable.h"         // for isCtorDtorAssign
+#include "CodeGen/OperatorTable.h"  // for isCtorDtorAssign
 #include "Common/SemanticError.h"
 #include "Common/Stats/Counter.h"
@@ -29 +28 @@
 #include "InitTweak/InitTweak.h"
 #include "ResolvExpr/Cost.h"
-#include "ResolvExpr/CandidateFinder.hpp"  // for referenceToRvalueConversion
-#include "ResolvExpr/Unify.h"
+#include "ResolvExpr/typeops.h"
 #include "SymTab/Mangler.h"
 
@@ -71 +69 @@
         if ( baseExpr ) {
                 if (baseExpr->env) {
-                        Expr * base = deepCopy(baseExpr);
+                        Expr * base = shallowCopy(baseExpr);
                         const TypeSubstitution * subs = baseExpr->env;
                         base->env = nullptr;
@@ -261 +259 @@
 void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) {
         // default handling of conflicts is to raise an error
-        addIdCommon( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
 }
 
 void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
         // default handling of conflicts is to raise an error
-        addIdCommon( decl, OnConflict::error(), nullptr, deleter );
+        addId( decl, OnConflict::error(), nullptr, deleter );
 }
 
@@ -278 +276 @@
                 } else {
                         // typedef redeclarations are errors only if types are different
-                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base ) ) {
+                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base, SymbolTable{} ) ) {
                                 SemanticError( added->location, "redeclaration of " + added->name );
                         }
@@ -643 +641 @@
         } else if ( existing.id->linkage.is_mangled
                         || ResolvExpr::typesCompatible(
-                                added->get_type(), existing.id->get_type() ) ) {
+                                added->get_type(), existing.id->get_type(), SymbolTable{} ) ) {
 
                 // it is a conflict if one declaration is deleted and the other is not
@@ -678 +676 @@
 }
 
-void SymbolTable::addIdCommon(
-                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 Decl * deleter ) {
         SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
         if (kind == NUMBER_OF_KINDS) { // not a special decl
-                addIdToTable(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
         }
         else {
@@ -696 +694 @@
                         assertf(false, "special decl with non-function type");
                 }
-                addIdToTable(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
-        }
-}
-
-void SymbolTable::addIdToTable(
-                const DeclWithType * decl, const std::string & lookupKey,
-                IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts,
-                const Expr * baseExpr, const Decl * deleter ) {
+                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+
+void SymbolTable::addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
+                const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -780 +777 @@
 void SymbolTable::addMembers(
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
-        for ( const ptr<Decl> & decl : aggr->members ) {
-                auto dwt = decl.as<DeclWithType>();
-                if ( nullptr == dwt ) continue;
-                addIdCommon( dwt, handleConflicts, expr );
-                // Inline through unnamed struct/union members.
-                if ( "" != dwt->name ) continue;
-                const Type * t = dwt->get_type()->stripReferences();
-                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
-                        if ( ! dynamic_cast<const StructInstType *>(rty)
-                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
-                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
-                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
-                        expr = mutate_field(expr, &Expr::env, nullptr);
-                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
-                        base = mutate_field(base, &Expr::env, tmp);
-
-                        addMembers(
-                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+        for ( const Decl * decl : aggr->members ) {
+                if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) {
+                        addId( dwt, handleConflicts, expr );
+                        if ( dwt->name == "" ) {
+                                const Type * t = dwt->get_type()->stripReferences();
+                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                                        expr = mutate_field(expr, &Expr::env, nullptr);
+                                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                                        base = mutate_field(base, &Expr::env, tmp);
+
+                                        addMembers(
+                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
+                                }
+                        }
                 }
         }