Changes in / [13edbac:2856982c]

Files:

• src/AST/Convert.cpp (modified) (2 diffs)
• src/AST/Decl.hpp (modified) (1 diff)
• src/AST/Fwd.hpp (modified) (1 diff)
• src/AST/Pass.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Print.cpp (modified) (1 diff)
• src/AST/Visitor.hpp (modified) (1 diff)
• src/Common/CodeLocationTools.cpp (modified) (1 diff)
• src/Common/PassVisitor.h (modified) (2 diffs)
• src/Common/PassVisitor.impl.h (modified) (1 diff)
• src/Parser/DeclarationNode.cc (modified) (2 diffs)
• src/Parser/ExpressionNode.cc (modified) (1 diff)
• src/Parser/TypeData.cc (modified) (1 diff)
• src/ResolvExpr/CommonType.cc (modified) (2 diffs)
• src/ResolvExpr/ConversionCost.cc (modified) (1 diff)
• src/SynTree/Declaration.h (modified) (1 diff)
• src/SynTree/InlineValueDecl.cc (deleted)
• src/SynTree/Mutator.h (modified) (1 diff)
• src/SynTree/SynTree.h (modified) (1 diff)
• src/SynTree/Visitor.h (modified) (1 diff)
• src/SynTree/module.mk (modified) (1 diff)
• src/Validate/EnumAndPointerDecay.cpp (modified) (3 diffs)
• src/Validate/LinkReferenceToTypes.cpp (modified) (2 diffs)
• tests/enum_tests/.expect/enumInlineValue.txt (modified) (1 diff)
• tests/enum_tests/.expect/qualifiedEnum.cfa (modified) (1 diff)
• tests/enum_tests/enumInlineValue.cfa (modified) (1 diff)
• tests/enum_tests/qualifiedEnum.cfa (modified) (1 diff)

src/AST/Convert.cpp

@@ -234 +234 @@
                 }
                 return declWithTypePostamble( decl, node );
-        }
-
-        // InlineValueDecl vanish after EnumAndPointerDecay pass so no necessary to implement NewToOld
-        const ast::DeclWithType * visit( const ast::InlineValueDecl * node ) override final {   
-                assert( false );
-                (void) node;
-                return nullptr;
         }
 
@@ -1870 +1863 @@
         }
 
-        virtual void visit( const InlineValueDecl * old ) override final {
-                if ( inCache( old ) ) {
-                        return;
-                }
-                auto&& type = GET_ACCEPT_1(type, Type);
-                auto&& attr = GET_ACCEPT_V(attributes, Attribute);
- 
-                auto decl = new ast::InlineValueDecl(
-                        old->location,
-                        old->name,
-                        type,
-                        { old->get_storageClasses().val },
-                        { old->linkage.val },
-                        std::move(attr),
-                        { old->get_funcSpec().val }
-                );
-                cache.emplace(old, decl);
-                assert(cache.find( old ) != cache.end());
-                decl->scopeLevel = old->scopeLevel;
-                decl->mangleName = old->mangleName;
-                decl->isDeleted  = old->isDeleted;
-                decl->asmName    = GET_ACCEPT_1(asmName, Expr);
-                decl->uniqueId   = old->uniqueId;
-                decl->extension  = old->extension;
-
-                this->node = decl;
-        }
-
         virtual void visit( const CompoundStmt * old ) override final {
                 if ( inCache( old ) ) return;

src/AST/Decl.hpp

@@ -414 +414 @@
 };
 
-class InlineValueDecl final : public DeclWithType {
-public:
-        ptr<Type> type;
-
-        InlineValueDecl( const CodeLocation & loc, const std::string & name, const Type * type,
-                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ) {}
-
-        const Type * get_type() const override { return type; }
-        void set_type( const Type * ty ) override { type = ty; }
-
-        const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        InlineValueDecl * clone() const override { return new InlineValueDecl{ *this }; }
-        MUTATE_FRIEND
-};
 }
 

src/AST/Fwd.hpp

@@ -37 +37 @@
 class DirectiveDecl;
 class StaticAssertDecl;
-class InlineValueDecl;
 
 class Stmt;

src/AST/Pass.hpp

@@ -141 +141 @@
         const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) override final;
         const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
-        const ast::DeclWithType *     visit( const ast::InlineValueDecl      * ) override final;
         const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;
         const ast::Stmt *             visit( const ast::ExprStmt             * ) override final;

src/AST/Pass.impl.hpp

@@ -803 +803 @@
 
 //--------------------------------------------------------------------------
-// DeclWithType
-template< typename core_t >
-const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineValueDecl * node ) {
-        VISIT_START( node );
-
-        if ( __visit_children() ) {
-                {
-                        guard_symtab guard { *this };
-                        maybe_accept( node, &InlineValueDecl::type );
-                }
-        }
-
-        VISIT_END( DeclWithType, node );
-}
-
-//--------------------------------------------------------------------------
 // CompoundStmt
 template< typename core_t >

src/AST/Print.cpp

@@ -398 +398 @@
         virtual const ast::Decl * visit( const ast::StructDecl * node ) override final {
                 print(node);
-                return node;
-        }
-
-        virtual const ast::DeclWithType * visit( const ast::InlineValueDecl * node ) override final {
-                os << "inline ";
-                if ( ! node->name.empty() ) os << node->name;
-
                 return node;
         }

src/AST/Visitor.hpp

@@ -33 +33 @@
     virtual const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) = 0;
     virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
-    virtual const ast::DeclWithType *     visit( const ast::InlineValueDecl      * ) = 0;
     virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ExprStmt             * ) = 0;

src/Common/CodeLocationTools.cpp

@@ -111 +111 @@
     macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
-    macro(InlineValueDecl, DeclWithType) \
     macro(CompoundStmt, CompoundStmt) \
     macro(ExprStmt, Stmt) \

src/Common/PassVisitor.h

@@ -81 +81 @@
         virtual void visit( StaticAssertDecl * assertDecl ) override final;
         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
-        virtual void visit( InlineValueDecl * valueDecl ) override final;
-        virtual void visit( const InlineValueDecl * valueDecl ) override final;
 
         virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -275 +273 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
-        virtual DeclarationWithType * mutate( InlineValueDecl * valueDecl ) override final;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -1047 +1047 @@
 
 //--------------------------------------------------------------------------
-// InlineValueDecl
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( InlineValueDecl * node ) {
-        VISIT_START( node );
-
-        maybeAccept_impl( node->type, *this );
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( const InlineValueDecl * node ) {
-        VISIT_START( node );
-
-        maybeAccept_impl( node->type, *this );
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-DeclarationWithType * PassVisitor< pass_type >::mutate( InlineValueDecl * node ) {
-        MUTATE_START( node );
-
-        maybeMutate_impl( node->type, *this );
-
-        MUTATE_END( DeclarationWithType, node );
-}
-
-//--------------------------------------------------------------------------
 // CompoundStmt
 template< typename pass_type >

src/Parser/DeclarationNode.cc

@@ -27 +27 @@
 #include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
 #include "SynTree/Attribute.h"     // for Attribute
-#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineValueDecl, Declaration
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, Declaration
 #include "SynTree/Expression.h"    // for Expression, ConstantExpr
 #include "SynTree/Statement.h"     // for AsmStmt
@@ -1165 +1165 @@
                 SemanticError( this, "invalid function specifier for " );
         } // if
-        if ( enumInLine ) {
-                return new InlineValueDecl( *name, storageClasses, linkage, nullptr );
-        } // if
         assertf( name, "ObjectDecl must a have name\n" );
         return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );

src/Parser/ExpressionNode.cc

@@ -519 +519 @@
                 }
         }
-        return new QualifiedNameExpr( newDecl, name->name );
+        auto ret =  new QualifiedNameExpr( newDecl, name->name );
+        if ( auto e = dynamic_cast<EnumDecl*>(newDecl) ) {
+                auto enumInst = new EnumInstType( Type::Qualifiers(), e );
+                auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
+        }
+        return ret;
 }
 

src/Parser/TypeData.cc

@@ -925 +925 @@
         for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->enumInLine ) {
-                        // Do Nothing
-                } else if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
+                        // Tell the compiler this is a inline value placeholder
+                        ObjectDecl * member = dynamic_cast< ObjectDecl* >(* members);
+                        member->enumInLine = true;
+                }
+                if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
                 } else if ( cur->has_enumeratorValue() ) {

src/ResolvExpr/CommonType.cc

@@ -991 +991 @@
                                 add_qualifiers( result, type2->qualifiers );
                         } else {
+                                // xxx - does unifying a ref with typed enumInst makes sense?
                                 if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                         result = commonType( type2, ref, tenv, need, have, open, widen, symtab );
@@ -1009 +1010 @@
 
                 void postvisit( const ast::EnumInstType * enumInst ) {
+                        // reuse BasicType/EnumInstType common type by swapping
+                        // xxx - is this already handled by unify?
                         if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                 result = commonType( type2, enumInst, tenv, need, have, open, widen, symtab);

src/ResolvExpr/ConversionCost.cc

@@ -720 +720 @@
                 costCalc( baseType, dst, srcIsLvalue, symtab, env );
         } else {
+                (void)enumInstType;
                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
                 cost = costCalc( integer, dst, srcIsLvalue, symtab, env );

src/SynTree/Declaration.h

@@ -449 +449 @@
 };
 
-
-class InlineValueDecl : public DeclarationWithType {
-        typedef DeclarationWithType Parent;
-  public:
-        Type * type;
-
-        InlineValueDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Type * type,
-                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
-        InlineValueDecl( const InlineValueDecl & other );
-        virtual ~InlineValueDecl();
-
-        virtual Type * get_type() const override { return type; }
-        virtual void set_type(Type * newType) override { type = newType; }
-
-        static InlineValueDecl * newInlineValueDecl( const std::string & name, Type * type );
-
-        virtual InlineValueDecl * clone() const override { return new InlineValueDecl( *this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-        virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
-
-};
-
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 

src/SynTree/Mutator.h

@@ -36 +36 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) = 0;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
-        virtual DeclarationWithType * mutate( InlineValueDecl * inlineValueDecl ) = 0;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;

src/SynTree/SynTree.h

@@ -38 +38 @@
 class DirectiveDecl;
 class StaticAssertDecl;
-class InlineValueDecl;
 
 class Statement;

src/SynTree/Visitor.h

@@ -49 +49 @@
         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
-        virtual void visit( InlineValueDecl * node ) { visit( const_cast<const InlineValueDecl *>(node) ); }
-        virtual void visit( const InlineValueDecl * valueDecl ) = 0;
 
         virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }

src/SynTree/module.mk

@@ -42 +42 @@
       SynTree/Initializer.cc \
       SynTree/Initializer.h \
-      SynTree/InlineValueDecl.cc \
       SynTree/Label.h \
       SynTree/LinkageSpec.cc \

src/Validate/EnumAndPointerDecay.cpp

@@ -21 +21 @@
 #include "AST/Type.hpp"
 #include "SymTab/FixFunction.h"
-#include "Validate/NoIdSymbolTable.hpp"
 
 namespace Validate {
@@ -27 +26 @@
 namespace {
 
-struct EnumAndPointerDecayCore final : public WithNoIdSymbolTable, public ast::WithCodeLocation {
+struct EnumAndPointerDecayCore final : public ast::WithCodeLocation {
         ast::EnumDecl const * previsit( ast::EnumDecl const * decl );
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
@@ -40 +39 @@
         // Set the type of each member of the enumeration to be EnumContant.
         auto mut = ast::mutate( decl );
-        std::vector<ast::ptr<ast::Decl>> buffer;
-        for ( auto it = decl->members.begin(); it != decl->members.end(); ++it ) {
-                if ( ast::ObjectDecl const * object = (*it).as<ast::ObjectDecl>() ) {
-                        buffer.push_back( ast::mutate_field( object, &ast::ObjectDecl::type, new ast::EnumInstType( decl, ast::CV::Const ) ) );
-                } else if ( ast::InlineValueDecl const * value = (*it).as<ast::InlineValueDecl>() ) {
-                        if ( auto targetEnum = symtab.lookupEnum( value->name ) ) {
-                                for ( auto singleMember : targetEnum->members ) {
-                                        auto copyingMember = singleMember.as<ast::ObjectDecl>();
-                                        buffer.push_back( new ast::ObjectDecl(
-                                                value->location, // use the "inline" location
-                                                copyingMember->name,
-                                                new ast::EnumInstType( decl, ast::CV::Const ),
-                                                // Construct a new EnumInstType as the type
-                                                copyingMember->init,
-                                                copyingMember->storage,
-                                                copyingMember->linkage,
-                                                copyingMember->bitfieldWidth,
-                                                {},
-                                                copyingMember->funcSpec
-                                        ) );
-                                }
-                        }
-                }
+        for ( ast::ptr<ast::Decl> & member : mut->members ) {
+                ast::ObjectDecl const * object = member.strict_as<ast::ObjectDecl>();
+                member = ast::mutate_field( object, &ast::ObjectDecl::type,
+                        new ast::EnumInstType( decl, ast::CV::Const ) );
         }
-        mut->members = buffer;
         return mut;
 }

src/Validate/LinkReferenceToTypes.cpp

@@ -185 +185 @@
                                 decl = mut;
                         }
-                        // visit the base
                 } else if ( auto ptr = decl->base.as<ast::PointerType>() ) {
                         if ( auto base = ptr->base.as<ast::TypeInstType>() ) {
@@ -204 +203 @@
 
         // The following section 
+        auto mut = ast::mutate( decl );
+        std::vector<ast::ptr<ast::Decl>> buffer;
+        for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) {
+                auto member = (*it).as<ast::ObjectDecl>();
+                if ( member->enumInLine ) {
+                        auto targetEnum = symtab.lookupEnum( member->name );
+                        if ( targetEnum ) {                     
+                                for ( auto singleMamber : targetEnum->members ) {
+                                        auto tm = singleMamber.as<ast::ObjectDecl>();
+                                        auto t = new ast::ObjectDecl(
+                                                member->location, // use the "inline" location
+                                                tm->name,
+                                                new ast::EnumInstType( decl, ast::CV::Const ),
+                                                // Construct a new EnumInstType as the type
+                                                tm->init,
+                                                tm->storage,
+                                                tm->linkage,
+                                                tm->bitfieldWidth,
+                                                {}, // enum member doesn't have attribute
+                                                tm->funcSpec
+                                        );
+                                        t->importValue = true;
+                                        buffer.push_back(t);
+                                }
+                        }
+                } else {
+                        auto search_it = std::find_if( buffer.begin(), buffer.end(), [member](ast::ptr<ast::Decl> cur) {
+                                auto curAsObjDecl = cur.as<ast::ObjectDecl>();
+                                return (curAsObjDecl->importValue) && (curAsObjDecl->name == member->name);
+                        });
+                        if ( search_it != buffer.end() ) {
+                                buffer.erase( search_it ); // Found an import enum value that has the same name
+                                // override the imported value
+                        }
+                        buffer.push_back( *it );
+                }
+        }
+        mut->members = buffer;
+        decl = mut;
 
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );

tests/enum_tests/.expect/enumInlineValue.txt

@@ -1 +1 @@
 enumB.A is 5
-enumB.B is 6
+enumB.B is 10
 enumB.D is 11
 enumB.E is 12

tests/enum_tests/.expect/qualifiedEnum.cfa

@@ -1 @@
-l :1
+l :0

tests/enum_tests/enumInlineValue.cfa

@@ -6 +6 @@
 enum enumB {
     inline enumA,
-    E
+    E, B=10
 };
 

tests/enum_tests/qualifiedEnum.cfa

@@ -8 +8 @@
 
 int main() {
-    enum Level l = Level.MEDIUM;
+    enum Level l = Level.LOW;
     sout | "l :" | l;
     return 0;