Changes in / [db6cdc0:1fb09eff]

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/TypeData.cc (modified) (1 diff)
• Parser/TypeData.h (modified) (1 diff)
• Parser/parser.yy (modified) (2 diffs)
• SynTree/Declaration.h (modified) (2 diffs)

src/AST/Convert.cpp

@@ -1764 +1764 @@
                         { old->linkage.val },
                         GET_ACCEPT_1(base, Type),
-                        old->hide == EnumDecl::EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible,
                         old->enumValues
                 );

src/AST/Decl.hpp

@@ -315 +315 @@
         // enum (type_optional) Name {...} 
         ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
-        enum class EnumHiding { Visible, Hide } hide;
-
-        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,
+
+        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false, 
                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,
-                Type const * base = nullptr, EnumHiding hide = EnumHiding::Hide,
+                Type const * base = nullptr,
                 std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
-        : AggregateDecl( loc, name, std::move(attrs), linkage ), isTyped(isTyped), base(base), hide(hide), enumValues(enumValues) {}
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), isTyped(isTyped), base(base), enumValues(enumValues) {}
 
         /// gets the integer value for this enumerator, returning true iff value found

src/AST/Pass.impl.hpp

@@ -686 +686 @@
 
         if ( __visit_children() ) {
-                if ( node->hide == ast::EnumDecl::EnumHiding::Hide ) {
-                        guard_symtab guard { *this };
-                        maybe_accept( node, &EnumDecl::base );
-                        maybe_accept( node, &EnumDecl::params     );
-                        maybe_accept( node, &EnumDecl::members    );
-                        maybe_accept( node, &EnumDecl::attributes );
-                } else {
-                        maybe_accept( node, &EnumDecl::base );
-                        maybe_accept( node, &EnumDecl::params     );
-                        maybe_accept( node, &EnumDecl::members    );
-                        maybe_accept( node, &EnumDecl::attributes );
-                }
+                // unlike structs, traits, and unions, enums inject their members into the global scope
+                maybe_accept( node, &EnumDecl::base );
+                maybe_accept( node, &EnumDecl::params     );
+                maybe_accept( node, &EnumDecl::members    );
+                maybe_accept( node, &EnumDecl::attributes );
         }
 

src/Parser/DeclarationNode.cc

@@ -254 +254 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base, EnumHiding hiding ) {
+DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
@@ -262 +262 @@
         newnode->type->enumeration.anon = name == nullptr;
         newnode->type->enumeration.typed = typed;
-        newnode->type->enumeration.hiding = hiding;
         if ( base && base->type)  {
                 newnode->type->base = base->type;

src/Parser/ParseNode.h

@@ -239 +239 @@
         static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
         static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
+        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr );
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
         static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );

src/Parser/TypeData.cc

@@ -923 +923 @@
         buildList( td->enumeration.constants, ret->get_members() );
         list< Declaration * >::iterator members = ret->get_members().begin();
-        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? EnumDecl::EnumHiding::Hide : EnumDecl::EnumHiding::Visible;
         for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->enumInLine ) {

src/Parser/TypeData.h

@@ -60 +60 @@
                 bool anon;
                 bool typed;
-                EnumHiding hiding;
         };
 

src/Parser/parser.yy

@@ -2558 +2558 @@
                 { typedefTable.makeTypedef( *$3 ); }
           hide_opt '{' enumerator_list comma_opt '}'
-          { $$ = DeclarationNode::newEnum( $3, $7, true, false, nullptr, $5 )->addQualifiers( $2 ); }
+          { $$ = DeclarationNode::newEnum( $3, $7, true, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt typedef_name                          // unqualified type name
           hide_opt '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3->name, $6, true, false, nullptr, $4 )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3->name, $6, true, false )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
@@ -2580 +2580 @@
           hide_opt '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $11, true, true, $3, $9 )->addQualifiers( $5 )->addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6, $11, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | ENUM '(' ')' attribute_list_opt identifier attribute_list_opt
           hide_opt '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $5, $9, true, true, nullptr, $7 )->addQualifiers( $4 )->addQualifiers( $6 );
+                        $$ = DeclarationNode::newEnum( $5, $9, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt
           hide_opt '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6->name, $10, true, true, $3, $8 )->addQualifiers( $5 )->addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6->name, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt
           hide_opt '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $5->name, $9, true, true, nullptr, $7 )->addQualifiers( $4 )->addQualifiers( $6 );
+                        $$ = DeclarationNode::newEnum( $5->name, $9, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
                 }
         | enum_type_nobody

src/SynTree/Declaration.h

@@ -340 +340 @@
         bool isTyped;
         Type * base;
-        enum EnumHiding { Visible, Hide } hide;
 
         EnumDecl( const std::string & name,
@@ -346 +345 @@
           bool isTyped = false, LinkageSpec::Spec linkage = LinkageSpec::Cforall,
           Type * baseType = nullptr ) 
-          : Parent( name, attributes, linkage ), isTyped(isTyped), base( baseType ) {}
+          : Parent( name, attributes, linkage ),isTyped(isTyped), base( baseType ) {}
         EnumDecl( const EnumDecl & other ) 
           : Parent( other ), isTyped( other.isTyped), base( other.base ) {}