Changeset 906e24d for src/SynTree

Timestamp:

Sep 15, 2016, 10:17:16 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

aa8f9df

Parents:

96a10cd

git-author:

Rob Schluntz <rschlunt@…> (09/14/16 22:32:34)

git-committer:

Rob Schluntz <rschlunt@…> (09/15/16 10:17:16)

Message:

replace results list on Expressions with a single Type field

Location:

src/SynTree

Files:

• AddressExpr.cc (modified) (2 diffs)
• ApplicationExpr.cc (modified) (2 diffs)
• CommaExpr.cc (modified) (1 diff)
• Expression.cc (modified) (16 diffs)
• Expression.h (modified) (2 diffs)
• Mutator.cc (modified) (23 diffs)
• Type.h (modified) (3 diffs)
• Visitor.cc (modified) (11 diffs)

src/SynTree/AddressExpr.cc

@@ -19 +19 @@
 
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
-        for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
-                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
-        } // for
+        if ( arg->has_result() ) {
+                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
+        }
 }
 
@@ -35 +35 @@
         if ( arg ) {
                 os << std::string( indent+2, ' ' );
-    arg->print( os, indent+2 );
+                arg->print( os, indent+2 );
         } // if
 }

src/SynTree/ApplicationExpr.cc

@@ -21 +21 @@
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
-
+#include "ResolvExpr/typeops.h"
 
 ParamEntry::ParamEntry( const ParamEntry &other ) :
@@ -43 +43 @@
 
 ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
-        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
-        assert( pointer );
-        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
-        assert( function );
+        PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
+        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
 
-        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                get_results().push_back( (*i)->get_type()->clone() );
-        } // for
+        set_result( ResolvExpr::extractResultType( function ) );
+
+        assert( has_result() );
 }
 

src/SynTree/CommaExpr.cc

@@ -23 +23 @@
         // to false on all result types. Actually doing this causes some strange things
         // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
-        cloneAll( arg2->get_results(), get_results() );
-        // for ( Type *& type : get_results() ) {
-        //      type->set_isLvalue( false );
-        // }
+        set_result( maybeClone( arg2->get_result() ) );
+        // get_type->set_isLvalue( false );
 }
 

src/SynTree/Expression.cc

@@ -31 +31 @@
 
 
-Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
-
-Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
-        cloneAll( other.results, results );
+Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
+
+Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
 }
 
@@ -40 +39 @@
         delete env;
         delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
-        deleteAll( results );
-}
-
-void Expression::add_result( Type *t ) {
-        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
-                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
-        } else {
-                results.push_back(t);
-        } // if
+        delete result;
 }
 
@@ -68 +59 @@
 
 ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
-        add_result( constant.get_type()->clone() );
+        set_result( constant.get_type()->clone() );
 }
 
@@ -85 +76 @@
         assert( var );
         assert( var->get_type() );
-        add_result( var->get_type()->clone() );
-        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
-                (*i)->set_isLvalue( true );
-        } // for
+        Type * type = var->get_type()->clone();
+        type->set_isLvalue( true );
+        set_result( type );
 }
 
@@ -110 +100 @@
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -141 +131 @@
 AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -172 +162 @@
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -197 +187 @@
 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -229 +219 @@
 
 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
-        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
@@ -284 +274 @@
 
 CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        add_result(toType);
+        set_result(toType);
 }
 
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+        set_result( new VoidType( Type::Qualifiers() ) );
 }
 
@@ -303 +294 @@
         arg->print(os, indent+2);
         os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        if ( results.empty() ) {
-                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
+        os << std::string( indent+2, ' ' );
+        if ( result->isVoid() ) {
+                os << "nothing";
         } else {
-                printAll(results, os, indent+2);
+                result->print( os, indent+2 );
         } // if
+        os << std::endl;
         Expression::print( os, indent );
 }
@@ -338 +331 @@
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-        add_result( member->get_type()->clone() );
-        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
-                (*i)->set_isLvalue( true );
-        } // for
+        set_result( member->get_type()->clone() );
+        get_result()->set_isLvalue( true );
 }
 
@@ -419 +410 @@
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
@@ -477 +468 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        cloneAll( callExpr->get_results(), results );
+        assert( callExpr->has_result() );
+        set_result( callExpr->get_result()->clone() );
 }
 
@@ -510 +502 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        cloneAll( arg->get_results(), results );
+        set_result( maybeClone( arg->get_result() ) );
 }
 
@@ -530 +522 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        add_result( type->clone() );
+        set_result( type->clone() );
 }
 

src/SynTree/Expression.h

@@ -32 +32 @@
         virtual ~Expression();
 
-        std::list<Type *>& get_results() { return results; }
-        void add_result( Type *t );
+        Type *& get_result() { return result; }
+        void set_result( Type *newValue ) { result = newValue; }
+        bool has_result() const { return result != nullptr; }
 
         TypeSubstitution *get_env() const { return env; }
@@ -47 +48 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
-        std::list<Type *> results;
+        Type * result;
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name

src/SynTree/Mutator.cc

@@ -178 +178 @@
 
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
-        mutateAll( applicationExpr->get_results(), *this );
+        applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
         applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
         mutateAll( applicationExpr->get_args(), *this );
@@ -185 +185 @@
 
 Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
-        mutateAll( untypedExpr->get_results(), *this );
+        untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
         mutateAll( untypedExpr->get_args(), *this );
         return untypedExpr;
@@ -191 +191 @@
 
 Expression *Mutator::mutate( NameExpr *nameExpr ) {
-        mutateAll( nameExpr->get_results(), *this );
+        nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
         return nameExpr;
 }
 
 Expression *Mutator::mutate( AddressExpr *addressExpr ) {
-        mutateAll( addressExpr->get_results(), *this );
+        addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
         addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
         return addressExpr;
@@ -202 +202 @@
 
 Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
-        mutateAll( labelAddressExpr->get_results(), *this );
+        labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
         labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
         return labelAddressExpr;
@@ -208 +208 @@
 
 Expression *Mutator::mutate( CastExpr *castExpr ) {
-        mutateAll( castExpr->get_results(), *this );
+        castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
         castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
         return castExpr;
@@ -214 +214 @@
 
 Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
-        mutateAll( memberExpr->get_results(), *this );
+        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
         return memberExpr;
@@ -220 +220 @@
 
 Expression *Mutator::mutate( MemberExpr *memberExpr ) {
-        mutateAll( memberExpr->get_results(), *this );
+        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
         return memberExpr;
@@ -226 +226 @@
 
 Expression *Mutator::mutate( VariableExpr *variableExpr ) {
-        mutateAll( variableExpr->get_results(), *this );
+        variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
         return variableExpr;
 }
 
 Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
-        mutateAll( constantExpr->get_results(), *this );
+        constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
 //  maybeMutate( constantExpr->get_constant(), *this )
         return constantExpr;
@@ -237 +237 @@
 
 Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
-        mutateAll( sizeofExpr->get_results(), *this );
+        sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
         if ( sizeofExpr->get_isType() ) {
                 sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
@@ -247 +247 @@
 
 Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
-        mutateAll( alignofExpr->get_results(), *this );
+        alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
         if ( alignofExpr->get_isType() ) {
                 alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
@@ -257 +257 @@
 
 Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
-        mutateAll( offsetofExpr->get_results(), *this );
+        offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         return offsetofExpr;
@@ -263 +263 @@
 
 Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
-        mutateAll( offsetofExpr->get_results(), *this );
+        offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         offsetofExpr->set_member( maybeMutate( offsetofExpr->get_member(), *this ) );
@@ -270 +270 @@
 
 Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
-        mutateAll( offsetPackExpr->get_results(), *this );
+        offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
         offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
         return offsetPackExpr;
@@ -276 +276 @@
 
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
-        mutateAll( attrExpr->get_results(), *this );
+        attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
         if ( attrExpr->get_isType() ) {
                 attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
@@ -286 +286 @@
 
 Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
-        mutateAll( logicalExpr->get_results(), *this );
+        logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
         logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
         logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
@@ -293 +293 @@
 
 Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
-        mutateAll( conditionalExpr->get_results(), *this );
+        conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
         conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
         conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
@@ -301 +301 @@
 
 Expression *Mutator::mutate( CommaExpr *commaExpr ) {
-        mutateAll( commaExpr->get_results(), *this );
+        commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
         commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
         commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
@@ -308 +308 @@
 
 Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
-        mutateAll( tupleExpr->get_results(), *this );
+        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
         mutateAll( tupleExpr->get_exprs(), *this );
         return tupleExpr;
@@ -314 +314 @@
 
 Expression *Mutator::mutate( SolvedTupleExpr *tupleExpr ) {
-        mutateAll( tupleExpr->get_results(), *this );
+        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
         mutateAll( tupleExpr->get_exprs(), *this );
         return tupleExpr;
@@ -320 +320 @@
 
 Expression *Mutator::mutate( TypeExpr *typeExpr ) {
-        mutateAll( typeExpr->get_results(), *this );
+        typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
         typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
         return typeExpr;
@@ -340 +340 @@
 
 Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
-        mutateAll( ctorExpr->get_results(), *this );
+        ctorExpr->set_result( maybeMutate( ctorExpr->get_result(), *this ) );
         ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
         return ctorExpr;
@@ -346 +346 @@
 
 Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
-        mutateAll( compLitExpr->get_results(), *this );
+        compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
         compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
@@ -353 +353 @@
 
 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
-        mutateAll( valofExpr->get_results(), *this );
+        valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );
         return valofExpr;
 }

src/SynTree/Type.h

@@ -65 +65 @@
         std::list<TypeDecl*>& get_forall() { return forall; }
 
+        /// How many elemental types are represented by this type
+        virtual unsigned size() const { return 1; };
+        virtual bool isVoid() const { return size() == 0; }
+
         virtual Type *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
@@ -77 +81 @@
   public:
         VoidType( const Type::Qualifiers &tq );
+
+        virtual unsigned size() const { return 0; };
 
         virtual VoidType *clone() const { return new VoidType( *this ); }
@@ -353 +359 @@
 
         std::list<Type*>& get_types() { return types; }
+        virtual unsigned size() const { return types.size(); };
 
         virtual TupleType *clone() const { return new TupleType( *this ); }

src/SynTree/Visitor.cc

@@ -150 +150 @@
 
 void Visitor::visit( ApplicationExpr *applicationExpr ) {
-        acceptAll( applicationExpr->get_results(), *this );
+        maybeAccept( applicationExpr->get_result(), *this );
         maybeAccept( applicationExpr->get_function(), *this );
         acceptAll( applicationExpr->get_args(), *this );
@@ -156 +156 @@
 
 void Visitor::visit( UntypedExpr *untypedExpr ) {
-        acceptAll( untypedExpr->get_results(), *this );
+        maybeAccept( untypedExpr->get_result(), *this );
         acceptAll( untypedExpr->get_args(), *this );
 }
 
 void Visitor::visit( NameExpr *nameExpr ) {
-        acceptAll( nameExpr->get_results(), *this );
+        maybeAccept( nameExpr->get_result(), *this );
 }
 
 void Visitor::visit( AddressExpr *addressExpr ) {
-        acceptAll( addressExpr->get_results(), *this );
+        maybeAccept( addressExpr->get_result(), *this );
         maybeAccept( addressExpr->get_arg(), *this );
 }
 
 void Visitor::visit( LabelAddressExpr *labAddressExpr ) {
-        acceptAll( labAddressExpr->get_results(), *this );
+        maybeAccept( labAddressExpr->get_result(), *this );
         maybeAccept( labAddressExpr->get_arg(), *this );
 }
 
 void Visitor::visit( CastExpr *castExpr ) {
-        acceptAll( castExpr->get_results(), *this );
+        maybeAccept( castExpr->get_result(), *this );
         maybeAccept( castExpr->get_arg(), *this );
 }
 
 void Visitor::visit( UntypedMemberExpr *memberExpr ) {
-        acceptAll( memberExpr->get_results(), *this );
+        maybeAccept( memberExpr->get_result(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
 }
 
 void Visitor::visit( MemberExpr *memberExpr ) {
-        acceptAll( memberExpr->get_results(), *this );
+        maybeAccept( memberExpr->get_result(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
 }
 
 void Visitor::visit( VariableExpr *variableExpr ) {
-        acceptAll( variableExpr->get_results(), *this );
+        maybeAccept( variableExpr->get_result(), *this );
 }
 
 void Visitor::visit( ConstantExpr *constantExpr ) {
-        acceptAll( constantExpr->get_results(), *this );
+        maybeAccept( constantExpr->get_result(), *this );
         maybeAccept( constantExpr->get_constant(), *this );
 }
 
 void Visitor::visit( SizeofExpr *sizeofExpr ) {
-        acceptAll( sizeofExpr->get_results(), *this );
+        maybeAccept( sizeofExpr->get_result(), *this );
         if ( sizeofExpr->get_isType() ) {
                 maybeAccept( sizeofExpr->get_type(), *this );
@@ -208 +208 @@
 
 void Visitor::visit( AlignofExpr *alignofExpr ) {
-        acceptAll( alignofExpr->get_results(), *this );
+        maybeAccept( alignofExpr->get_result(), *this );
         if ( alignofExpr->get_isType() ) {
                 maybeAccept( alignofExpr->get_type(), *this );
@@ -217 +217 @@
 
 void Visitor::visit( UntypedOffsetofExpr *offsetofExpr ) {
-        acceptAll( offsetofExpr->get_results(), *this );
+        maybeAccept( offsetofExpr->get_result(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
 }
 
 void Visitor::visit( OffsetofExpr *offsetofExpr ) {
-        acceptAll( offsetofExpr->get_results(), *this );
+        maybeAccept( offsetofExpr->get_result(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
         maybeAccept( offsetofExpr->get_member(), *this );
@@ -228 +228 @@
 
 void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
-        acceptAll( offsetPackExpr->get_results(), *this );
+        maybeAccept( offsetPackExpr->get_result(), *this );
         maybeAccept( offsetPackExpr->get_type(), *this );
 }
 
 void Visitor::visit( AttrExpr *attrExpr ) {
-        acceptAll( attrExpr->get_results(), *this );
+        maybeAccept( attrExpr->get_result(), *this );
         if ( attrExpr->get_isType() ) {
                 maybeAccept( attrExpr->get_type(), *this );
@@ -242 +242 @@
 
 void Visitor::visit( LogicalExpr *logicalExpr ) {
-        acceptAll( logicalExpr->get_results(), *this );
+        maybeAccept( logicalExpr->get_result(), *this );
         maybeAccept( logicalExpr->get_arg1(), *this );
         maybeAccept( logicalExpr->get_arg2(), *this );
@@ -248 +248 @@
 
 void Visitor::visit( ConditionalExpr *conditionalExpr ) {
-        acceptAll( conditionalExpr->get_results(), *this );
+        maybeAccept( conditionalExpr->get_result(), *this );
         maybeAccept( conditionalExpr->get_arg1(), *this );
         maybeAccept( conditionalExpr->get_arg2(), *this );
@@ -255 +255 @@
 
 void Visitor::visit( CommaExpr *commaExpr ) {
-        acceptAll( commaExpr->get_results(), *this );
+        maybeAccept( commaExpr->get_result(), *this );
         maybeAccept( commaExpr->get_arg1(), *this );
         maybeAccept( commaExpr->get_arg2(), *this );
@@ -261 +261 @@
 
 void Visitor::visit( TupleExpr *tupleExpr ) {
-        acceptAll( tupleExpr->get_results(), *this );
+        maybeAccept( tupleExpr->get_result(), *this );
         acceptAll( tupleExpr->get_exprs(), *this );
 }
 
 void Visitor::visit( SolvedTupleExpr *tupleExpr ) {
-        acceptAll( tupleExpr->get_results(), *this );
+        maybeAccept( tupleExpr->get_result(), *this );
         acceptAll( tupleExpr->get_exprs(), *this );
 }
 
 void Visitor::visit( TypeExpr *typeExpr ) {
-        acceptAll( typeExpr->get_results(), *this );
+        maybeAccept( typeExpr->get_result(), *this );
         maybeAccept( typeExpr->get_type(), *this );
 }
@@ -288 +288 @@
 
 void Visitor::visit( ConstructorExpr * ctorExpr ) {
-        acceptAll( ctorExpr->get_results(), *this );
+        maybeAccept( ctorExpr->get_result(), *this );
         maybeAccept( ctorExpr->get_callExpr(), *this );
 }
 
 void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
-        acceptAll( compLitExpr->get_results(), *this );
+        maybeAccept( compLitExpr->get_result(), *this );
         maybeAccept( compLitExpr->get_type(), *this );
         maybeAccept( compLitExpr->get_initializer(), *this );
@@ -299 +299 @@
 
 void Visitor::visit( UntypedValofExpr *valofExpr ) {
-        acceptAll( valofExpr->get_results(), *this );
+        maybeAccept( valofExpr->get_result(), *this );
         maybeAccept( valofExpr->get_body(), *this );
 }