Changeset 8a930c03 for src/AST/SymbolTable.cpp

Timestamp:

Jun 12, 2023, 12:05:58 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

fec8bd1

Parents:

2b78949 (diff), 38e266ca (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/AST/SymbolTable.cpp

@@ -18 +18 @@
 #include <cassert>
 
+#include "Copy.hpp"
 #include "Decl.hpp"
 #include "Expr.hpp"
@@ -87 +88 @@
 }
 
-SymbolTable::SymbolTable()
+SymbolTable::SymbolTable( ErrorDetection errorMode )
 : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
-  prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
+  prevScope(), scope( 0 ), repScope( 0 ), errorMode(errorMode) { ++*stats().count; }
 
 SymbolTable::~SymbolTable() { stats().size->push( idTable ? idTable->size() : 0 ); }
+
+void SymbolTable::OnFindError( CodeLocation location, std::string error ) const {
+        assertf( errorMode != AssertClean, "Name collision/redefinition, found during a compilation phase where none should be possible.  Detail: %s", error.c_str() );
+        if (errorMode == ValidateOnAdd) {
+                SemanticError(location, error);
+        }
+        assertf( errorMode == IgnoreErrors, "Unrecognized symbol-table error mode %d", errorMode );
+}
 
 void SymbolTable::enterScope() {
@@ -268 +277 @@
 }
 
-namespace {
-        /// true if redeclaration conflict between two types
-        bool addedTypeConflicts( const NamedTypeDecl * existing, const NamedTypeDecl * added ) {
-                if ( existing->base == nullptr ) {
-                        return false;
-                } else if ( added->base == nullptr ) {
-                        return true;
-                } else {
-                        // typedef redeclarations are errors only if types are different
-                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base, SymbolTable{} ) ) {
-                                SemanticError( added->location, "redeclaration of " + added->name );
-                        }
-                }
-                // does not need to be added to the table if both existing and added have a base that are
-                // the same
+bool SymbolTable::addedTypeConflicts(
+                const NamedTypeDecl * existing, const NamedTypeDecl * added ) const {
+        if ( existing->base == nullptr ) {
+                return false;
+        } else if ( added->base == nullptr ) {
                 return true;
-        }
-
-        /// true if redeclaration conflict between two aggregate declarations
-        bool addedDeclConflicts( const AggregateDecl * existing, const AggregateDecl * added ) {
-                if ( ! existing->body ) {
-                        return false;
-                } else if ( added->body ) {
-                        SemanticError( added, "redeclaration of " );
-                }
-                return true;
-        }
+        } else {
+                // typedef redeclarations are errors only if types are different
+                if ( ! ResolvExpr::typesCompatible( existing->base, added->base ) ) {
+                        OnFindError( added->location, "redeclaration of " + added->name );
+                }
+        }
+        // does not need to be added to the table if both existing and added have a base that are
+        // the same
+        return true;
+}
+
+bool SymbolTable::addedDeclConflicts( 
+                const AggregateDecl * existing, const AggregateDecl * added ) const {
+        if ( ! existing->body ) {
+                return false;
+        } else if ( added->body ) {
+                OnFindError( added, "redeclaration of " );
+        }
+        return true;
 }
 
@@ -642 +649 @@
         } else if ( existing.id->linkage.is_mangled
                         || ResolvExpr::typesCompatible(
-                                added->get_type(), existing.id->get_type(), SymbolTable{} ) ) {
+                                added->get_type(), existing.id->get_type() ) ) {
 
                 // it is a conflict if one declaration is deleted and the other is not
                 if ( deleter && ! existing.deleter ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added, "deletion of defined identifier " );
+                                OnFindError( added, "deletion of defined identifier " );
                         }
                         return true;
                 } else if ( ! deleter && existing.deleter ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added, "definition of deleted identifier " );
+                                OnFindError( added, "definition of deleted identifier " );
                         }
                         return true;
@@ -660 +667 @@
                 if ( isDefinition( added ) && isDefinition( existing.id ) ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added,
+                                OnFindError( added,
                                         isFunction( added ) ?
                                                 "duplicate function definition for " :
@@ -669 +676 @@
         } else {
                 if ( handleConflicts.mode == OnConflict::Error ) {
-                        SemanticError( added, "duplicate definition for " );
+                        OnFindError( added, "duplicate definition for " );
                 }
                 return true;
@@ -721 +728 @@
                 // Check that a Cforall declaration doesn't override any C declaration
                 if ( hasCompatibleCDecl( name, mangleName ) ) {
-                        SemanticError( decl, "Cforall declaration hides C function " );
+                        OnFindError( decl, "Cforall declaration hides C function " );
                 }
         } else {
@@ -727 +734 @@
                 // type-compatibility, which it may not be.
                 if ( hasIncompatibleCDecl( name, mangleName ) ) {
-                        SemanticError( decl, "conflicting overload of C function " );
+                        OnFindError( decl, "conflicting overload of C function " );
                 }
         }