Changes in / [8472c6c:beabdf3]

Location:

src

Files:

• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Type.cpp (modified) (2 diffs)
• AST/Type.hpp (modified) (2 diffs)
• ResolvExpr/CurrentObject.cc (modified) (4 diffs)
• ResolvExpr/CurrentObject.h (modified) (2 diffs)

src/AST/Pass.impl.hpp

@@ -2042 +2042 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
+                maybe_accept( node, &TupleType::members );
         }
 

src/AST/Type.cpp

@@ -10 +10 @@
 // Created On       : Mon May 13 15:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Apr  6 15:59:00 2023
-// Update Count     : 7
+// Last Modified On : Thu Nov 24  9:49:00 2022
+// Update Count     : 6
 //
 
@@ -199 +199 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( std::move(ts) ) {}
+: Type( q ), types( std::move(ts) ), members() {
+        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
+        // named, but members without initializer nodes end up getting constructors, which breaks
+        // things. This happens because the object decls have to be visited so that their types are
+        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
+        // be eliminated and replaced with a list-view over members. The temporary solution is to
+        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
+        // constructed. Potential better solutions include:
+        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
+        //      similar to the aggregate types.
+        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
+        //      by `genInit`, rather than the current boolean flag.
+        members.reserve( types.size() );
+        for ( const Type * ty : types ) {
+                members.emplace_back( new ObjectDecl{
+                        CodeLocation(), "", ty, new ListInit( CodeLocation(), {}, {}, NoConstruct ),
+                        Storage::Classes{}, Linkage::Cforall } );
+        }
+}
 
 bool isUnboundType(const Type * type) {

src/AST/Type.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Apr  6 15:58:00 2023
-// Update Count     : 9
+// Last Modified On : Thu Nov 24  9:47:00 2022
+// Update Count     : 8
 //
 
@@ -457 +457 @@
 public:
         std::vector<ptr<Type>> types;
+        std::vector<ptr<Decl>> members;
 
         TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} );

src/ResolvExpr/CurrentObject.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Tue Jun 13 15:28:32 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Thu Apr  6 16:25:00 2023
-// Update Count     : 17
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul  1 09:16:01 2022
+// Update Count     : 15
 //
 
@@ -593 +593 @@
 
 namespace ast {
-        /// Iterates members of a type by initializer.
-        class MemberIterator {
-        public:
-                virtual ~MemberIterator() {}
-
-                /// Internal set position based on iterator ranges.
-                virtual void setPosition(
-                        std::deque< ptr< Expr > >::const_iterator it,
-                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
-
-                /// Walks the current object using the given designators as a guide.
-                void setPosition( const std::deque< ptr< Expr > > & designators ) {
-                        setPosition( designators.begin(), designators.end() );
-                }
-
-                /// Retrieve the list of possible (Type,Designation) pairs for the
-                /// current position in the current object.
-                virtual std::deque< InitAlternative > operator* () const = 0;
-
-                /// True if the iterator is not currently at the end.
-                virtual operator bool() const = 0;
-
-                /// Moves the iterator by one member in the current object.
-                virtual MemberIterator & bigStep() = 0;
-
-                /// Moves the iterator by one member in the current subobject.
-                virtual MemberIterator & smallStep() = 0;
-
-                /// The type of the current object.
-                virtual const Type * getType() = 0;
-
-                /// The type of the current subobject.
-                virtual const Type * getNext() = 0;
-
-                /// Helper for operator*; aggregates must add designator to each init
-                /// alternative, but adding designators in operator* creates duplicates.
-                virtual std::deque< InitAlternative > first() const = 0;
-        };
-
         /// create a new MemberIterator that traverses a type correctly
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type );
@@ -723 +684 @@
 
                 void setPosition(
-                        std::deque<ast::ptr<ast::Expr>>::const_iterator begin,
-                        std::deque<ast::ptr<ast::Expr>>::const_iterator end
+                        std::deque< ptr< Expr > >::const_iterator begin,
+                        std::deque< ptr< Expr > >::const_iterator end
                 ) override {
                         if ( begin == end ) return;
@@ -938 +899 @@
 
         class TupleIterator final : public AggregateIterator {
-                MemberList * memberList;
-
-                TupleIterator( const CodeLocation & loc,
-                        const ast::TupleType * inst, MemberList * memberList )
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * inst )
                 : AggregateIterator(
-                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, *memberList
-                ), memberList( memberList ) {}
-
-                // The two layer constructor, this helper and the destructor
-                // are all to pretend that Tuples have members (they do not).
-                static MemberList * newImaginaryMembers( const ast::TupleType * inst ) {
-                        auto ret = new MemberList();
-                        ret->reserve( inst->types.size() );
-                        for ( const ast::Type * type : inst->types ) {
-                                ret->emplace_back( new ast::ObjectDecl(
-                                        CodeLocation(), "", type,
-                                        new ast::ListInit( CodeLocation(), {}, {}, ast::NoConstruct )
-                                ) );
-                        }
-                        return ret;
-                }
-
-        public:
-                TupleIterator( const CodeLocation & loc, const TupleType * inst )
-                : TupleIterator( loc, inst, newImaginaryMembers( inst ) ) {}
-
-                virtual ~TupleIterator() {
-                        delete memberList;
-                }
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
+                ) {}
 
                 operator bool() const override {

src/ResolvExpr/CurrentObject.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Thu Jun  8 11:07:25 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Thu Apr  6 16:14:00 2023
-// Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:36:48 2017
+// Update Count     : 3
 //
 
@@ -65 +65 @@
 
         /// Iterates members of a type by initializer
-        class MemberIterator;
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+
+                /// Internal set position based on iterator ranges
+                virtual void setPosition( 
+                        std::deque< ptr< Expr > >::const_iterator it, 
+                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
+
+                /// walks the current object using the given designators as a guide
+                void setPosition( const std::deque< ptr< Expr > > & designators ) {
+                        setPosition( designators.begin(), designators.end() );
+                }
+
+                /// retrieve the list of possible (Type,Designation) pairs for the current position in the 
+                /// current object
+                virtual std::deque< InitAlternative > operator* () const = 0;
+
+                /// true if the iterator is not currently at the end
+                virtual operator bool() const = 0;
+
+                /// moves the iterator by one member in the current object
+                virtual MemberIterator & bigStep() = 0;
+
+                /// moves the iterator by one member in the current subobject
+                virtual MemberIterator & smallStep() = 0;
+
+                /// the type of the current object
+                virtual const Type * getType() = 0;
+
+                /// the type of the current subobject
+                virtual const Type * getNext() = 0;
+        
+                /// helper for operator*; aggregates must add designator to each init alternative, but 
+                /// adding designators in operator* creates duplicates
+                virtual std::deque< InitAlternative > first() const = 0;
+        };
 
         /// Builds initializer lists in resolution