Changeset c7ebbec for src/AST

Timestamp:

Dec 21, 2023, 10:21:28 AM (6 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

116d7e2

Parents:

523e300

Message:

Reorganization of Linkage::Spec. is_mangled represented two properties with is_gcc_builtin separating them in one case. The second property is_overloadable which replaces is_gcc_builtin.

Location:

src/AST

Files:

• LinkageSpec.cpp (modified) (1 diff)
• LinkageSpec.hpp (modified) (4 diffs)
• SymbolTable.cpp (modified) (4 diffs)

src/AST/LinkageSpec.cpp

@@ -27 +27 @@
 namespace Linkage {
 
-Spec update( CodeLocation loc, Spec spec, const std::string * cmd ) {
+Spec update( const CodeLocation & loc, Spec spec, const std::string * cmd ) {
         assert( cmd );
         std::unique_ptr<const std::string> guard( cmd ); // allocated by lexer
         if ( *cmd == "\"Cforall\"" ) {
-                spec.is_mangled = true;
-                return spec;
+                spec.is_mangled = spec.is_overloadable = true;
         } else if ( *cmd == "\"C\"" ) {
-                spec.is_mangled = false;
-                return spec;
+                spec.is_mangled = spec.is_overloadable = false;
         } else {
                 SemanticError( loc, "Invalid linkage specifier %s", cmd->c_str() );
         }
+        return spec;
 }
 

src/AST/LinkageSpec.hpp

@@ -31 +31 @@
         Overrideable = 1 << 2,
         Builtin      = 1 << 3,
-        GccBuiltin   = 1 << 4
+        Overloadable = 1 << 4,
 };
 
@@ -43 +43 @@
                         bool is_overrideable : 1;
                         bool is_builtin      : 1;
-                        bool is_gcc_builtin  : 1;
+                        bool is_overloadable : 1;
                 };
         };
@@ -52 +52 @@
 using Spec = bitfield<spec_flags>;
 
-/// If `cmd` = "C" returns `spec` with `is_mangled = false`.
-/// If `cmd` = "Cforall" returns `spec` with `is_mangled = true`.
-Spec update( CodeLocation loc, Spec spec, const std::string * cmd );
+/// Updates `spec` based on `cmd` (should be "C" or "Cforall").
+Spec update( const CodeLocation & loc, Spec spec, const std::string * cmd );
 
 /// A human-readable name for this spec
@@ -62 +61 @@
 
 /// C built-in defined in prelude
-constexpr Spec Intrinsic  = { Mangle | Generate | Overrideable | Builtin };
+constexpr Spec Intrinsic  = { Mangle | Generate | Overrideable | Builtin | Overloadable };
 /// Ordinary Cforall
-constexpr Spec Cforall    = { Mangle | Generate };
+constexpr Spec Cforall    = { Mangle | Generate | Overloadable };
 /// C code: not overloadable, not mangled
 constexpr Spec C          = { Generate };
 /// Built by translator (e.g. struct assignment)
-constexpr Spec AutoGen    = { Mangle | Generate | Overrideable };
+constexpr Spec AutoGen    = { Mangle | Generate | Overrideable | Overloadable };
 /// GCC internal
-constexpr Spec Compiler   = { Mangle | Builtin | GccBuiltin };
+constexpr Spec Compiler   = { Builtin | Overloadable };
 /// Mangled builtins
-constexpr Spec BuiltinCFA = { Mangle | Generate | Builtin };
+constexpr Spec BuiltinCFA = { Mangle | Generate | Builtin | Overloadable };
 /// Non-mangled builtins
 constexpr Spec BuiltinC   = { Generate | Builtin };

src/AST/SymbolTable.cpp

@@ -644 +644 @@
                 // new definition shadows the autogenerated one, even at the same scope
                 return false;
-        } else if ( existing.id->linkage.is_mangled
+        } else if ( existing.id->linkage.is_overloadable
                         || ResolvExpr::typesCompatible(
                                 added->get_type(), existing.id->get_type() ) ) {
@@ -719 +719 @@
         // this ensures that no two declarations with the same unmangled name at the same scope
         // both have C linkage
-        if ( decl->linkage.is_mangled ) {
+        if ( decl->linkage.is_overloadable ) {
                 // Check that a Cforall declaration doesn't override any C declaration
                 if ( hasCompatibleCDecl( name, mangleName ) ) {
@@ -812 +812 @@
                 if ( decl.second.scope != scope ) continue;
                 // check for C decl with compatible type (by mangleName)
-                if ( ! decl.second.id->linkage.is_mangled && decl.first == mangleName ) return true;
+                if ( !decl.second.id->linkage.is_overloadable && decl.first == mangleName ) return true;
         }
 
@@ -829 +829 @@
                 if ( decl.second.scope != scope ) continue;
                 // check for C decl with incompatible type (by manglename)
-                if ( ! decl.second.id->linkage.is_mangled && decl.first != mangleName ) return true;
+                if ( !decl.second.id->linkage.is_overloadable && decl.first != mangleName ) return true;
         }