Changeset 13edbac

Timestamp:

Oct 28, 2022, 5:12:26 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master

Children:

be5f0a5

Parents:

2856982c (diff), fa2e183 (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

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 (added)
• 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;
         }
 
@@ -1863 +1870 @@
         }
 
+        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;
@@ -273 +275 @@
         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, Declaration
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineValueDecl, 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 @@
                 }
         }
-        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;
+        return new QualifiedNameExpr( newDecl, name->name );
 }
 

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 ) {
-                        // 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() ) {
+                        // Do Nothing
+                } else 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 );
@@ -1010 +1009 @@
 
                 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 {
@@ -26 +27 @@
 namespace {
 
-struct EnumAndPointerDecayCore final : public ast::WithCodeLocation {
+struct EnumAndPointerDecayCore final : public WithNoIdSymbolTable, public ast::WithCodeLocation {
         ast::EnumDecl const * previsit( ast::EnumDecl const * decl );
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
@@ -39 +40 @@
         // Set the type of each member of the enumeration to be EnumContant.
         auto mut = ast::mutate( decl );
-        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 ) );
+        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
+                                        ) );
+                                }
+                        }
+                }
         }
+        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>() ) {
@@ -203 +204 @@
 
         // 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 10
+enumB.B is 6
 enumB.D is 11
 enumB.E is 12

tests/enum_tests/.expect/qualifiedEnum.cfa

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

tests/enum_tests/enumInlineValue.cfa

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

tests/enum_tests/qualifiedEnum.cfa

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