Changes in src/SymTab/Mangler.cc [f465f0e:1da22500]

File:

• src/SymTab/Mangler.cc (modified) (8 diffs)

src/SymTab/Mangler.cc

@@ -35 +35 @@
                 namespace {
                         /// Mangles names to a unique C identifier
-                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
+                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
                                 Mangler( const Mangler & ) = delete;
@@ -55 +55 @@
                                 void postvisit( EnumInstType * aggregateUseType );
                                 void postvisit( TypeInstType * aggregateUseType );
-                                void postvisit( TraitInstType * inst );
                                 void postvisit( TupleType * tupleType );
                                 void postvisit( VarArgsType * varArgsType );
@@ -71 +70 @@
                                 bool typeMode;                  ///< Produce a unique mangled name for a type
                                 bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
-                                bool inFunctionType = false;    ///< Include type qualifiers if false.
 
                                 void mangleDecl( DeclarationWithType *declaration );
@@ -191 +189 @@
 
                         void Mangler::postvisit( ReferenceType * refType ) {
-                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
-                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
-                                // by pretending every reference type is a function parameter.
-                                GuardValue( inFunctionType );
-                                inFunctionType = true;
                                 printQualifiers( refType );
+                                mangleName << "R";
                                 maybeAccept( refType->base, *visitor );
                         }
@@ -212 +206 @@
                                 printQualifiers( functionType );
                                 mangleName << "F";
-                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
-                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
-                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
-                                GuardValue( inFunctionType );
-                                inFunctionType = true;
                                 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
                                 acceptAll( returnTypes, *visitor );
@@ -281 +270 @@
                         }
 
-                        void Mangler::postvisit( TraitInstType * inst ) {
-                                printQualifiers( inst );
-                                mangleName << "_Y" << inst->name << "_";
-                        }
-
                         void Mangler::postvisit( TupleType * tupleType ) {
                                 printQualifiers( tupleType );
@@ -320 +304 @@
                                 // skip if not including qualifiers
                                 if ( typeMode ) return;
+
                                 if ( ! type->get_forall().empty() ) {
                                         std::list< std::string > assertionNames;
@@ -352 +337 @@
                                         mangleName << "_";
                                 } // if
-                                if ( ! inFunctionType ) {
-                                        // these qualifiers do not distinguish the outermost type of a function parameter
-                                        if ( type->get_const() ) {
-                                                mangleName << "C";
-                                        } // if
-                                        if ( type->get_volatile() ) {
-                                                mangleName << "V";
-                                        } // if
-                                        // Removed due to restrict not affecting function compatibility in GCC
-                                        // if ( type->get_isRestrict() ) {
-                                        //      mangleName << "E";
-                                        // } // if
-                                        if ( type->get_atomic() ) {
-                                                mangleName << "A";
-                                        } // if
-                                }
+                                if ( type->get_const() ) {
+                                        mangleName << "C";
+                                } // if
+                                if ( type->get_volatile() ) {
+                                        mangleName << "V";
+                                } // if
                                 if ( type->get_mutex() ) {
                                         mangleName << "M";
                                 } // if
+                                // Removed due to restrict not affecting function compatibility in GCC
+                //              if ( type->get_isRestrict() ) {
+                //                      mangleName << "E";
+                //              } // if
                                 if ( type->get_lvalue() ) {
                                         // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                                         mangleName << "L";
                                 }
-
-                                if ( inFunctionType ) {
-                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
-                                        GuardValue( inFunctionType );
-                                        inFunctionType = false;
-                                }
+                                if ( type->get_atomic() ) {
+                                        mangleName << "A";
+                                } // if
                         }
                 }       // namespace