Changes in src/SynTree/Expression.cc [0f79853:487845d7]

File:

• src/SynTree/Expression.cc (modified) (10 diffs)

src/SynTree/Expression.cc

@@ -50 +50 @@
 }
 
-void Expression::spliceInferParams( Expression * other ) {
-        if ( ! other ) return;
-        for ( auto p : other->inferParams ) {
-                inferParams[p.first] = std::move( p.second );
-        }
-}
-
 Expression::~Expression() {
         delete env;
@@ -88 +81 @@
         constant.print( os );
         Expression::print( os, indent );
-}
-
-long long int ConstantExpr::intValue() const {
-        if ( BasicType * basicType = dynamic_cast< BasicType * >( result ) ) {
-                if ( basicType->isInteger() ) {
-                        return get_constant()->get_ival();
-                }
-        } else if ( dynamic_cast< OneType * >( result ) ) {
-                return 1;
-        } else if ( dynamic_cast< ZeroType * >( result ) ) {
-                return 0;
-        }
-        SemanticError( this, "Constant expression of non-integral type " );
 }
 
@@ -115 +95 @@
         //      assert( inst->baseEnum );
         //      EnumDecl * decl = inst->baseEnum;
-        //      long long int value;
-        //      if ( decl->valueOf( var, value ) ) {
-        //              type->set_lvalue( false );
+        //      for ( Declaration * member : decl->members ) {
+        //              if ( member == _var ) {
+        //                      type->set_lvalue( false );
+        //              }
         //      }
         // }
@@ -278 +259 @@
 }
 
-CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
 }
 
@@ -306 +287 @@
 }
 
-KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
-}
-
-KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
-}
-
-KeywordCastExpr::~KeywordCastExpr() {
-        delete arg;
-}
-
-const std::string & KeywordCastExpr::targetString() const {
-        static const std::string targetStrs[] = {
-                "coroutine", "thread", "monitor"
-        };
-        static_assert(
-                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
-                "Each KeywordCastExpr::Target should have a corresponding string representation"
-        );
-        return targetStrs[(unsigned long)target];
-}
-
-void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Keyword Cast of:" << std::endl << indent+1;
-        arg->print(os, indent+1);
-        os << std::endl << indent << "... to: ";
-        os << targetString();
-        Expression::print( os, indent );
-}
-
 VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
@@ -381 +333 @@
 }
 
+namespace {
+        TypeSubstitution makeSub( Type * t ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) {
+                        return makeSub( refType->get_base() );
+                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
+                } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
+                } else {
+                        assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );
+                }
+        }
+}
+
+
 MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
         assert( aggregate );
-        assert( aggregate->result );
-
-        TypeSubstitution sub = aggregate->result->genericSubstitution();
+
+        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
         Type * res = member->get_type()->clone();
         sub.apply( res );
@@ -437 +403 @@
                 } else {
                         // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->result->set_lvalue( true );
+                        ret->get_result()->set_lvalue( true );
                 }
         }
@@ -619 +585 @@
 
 StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
-        computeResult();
+        assert( statements );
+        std::list< Statement * > & body = statements->get_kids();
+        if ( ! body.empty() ) {
+                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
+                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
+                }
+        }
+        // ensure that StmtExpr has a result type
+        if ( ! result ) {
+                set_result( new VoidType( Type::Qualifiers() ) );
+        }
 }
 StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
@@ -629 +605 @@
         deleteAll( dtors );
         deleteAll( returnDecls );
-}
-void StmtExpr::computeResult() {
-        assert( statements );
-        std::list< Statement * > & body = statements->kids;
-        delete result;
-        result = nullptr;
-        if ( ! returnDecls.empty() ) {
-                // prioritize return decl for result type, since if a return decl exists, then
-                // the StmtExpr is currently in an intermediate state where the body will always
-                // give a void result type.
-                result = returnDecls.front()->get_type()->clone();
-        } else if ( ! body.empty() ) {
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        result = maybeClone( exprStmt->expr->result );
-                }
-        }
-        // ensure that StmtExpr has a result type
-        if ( ! result ) {
-                result = new VoidType( Type::Qualifiers() );
-        }
 }
 void StmtExpr::print( std::ostream &os, Indenter indent ) const {
@@ -732 +688 @@
 }
 
-DeletedExpr::DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt ) : expr( expr ), deleteStmt( deleteStmt ) {
-        assert( expr->result );
-        result = expr->result->clone();
-}
-DeletedExpr::DeletedExpr( const DeletedExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), deleteStmt( other.deleteStmt ) {}
-DeletedExpr::~DeletedExpr() {
-        delete expr;
-}
-
-void DeletedExpr::print( std::ostream & os, Indenter indent ) const {
-        os << "Deleted Expression" << std::endl << indent+1;
-        expr->print( os, indent+1 );
-        os << std::endl << indent+1 << "... deleted by: ";
-        deleteStmt->print( os, indent+1 );
-}
-
-
-DefaultArgExpr::DefaultArgExpr( Expression * expr ) : expr( expr ) {
-        assert( expr->result );
-        result = expr->result->clone();
-}
-DefaultArgExpr::DefaultArgExpr( const DefaultArgExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ) {}
-DefaultArgExpr::~DefaultArgExpr() {
-        delete expr;
-}
-
-void DefaultArgExpr::print( std::ostream & os, Indenter indent ) const {
-        os << "Default Argument Expression" << std::endl << indent+1;
-        expr->print( os, indent+1 );
-}
-
-GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {}
-GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {}
-GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {}
-GenericExpr::Association::~Association() {
-        delete type;
-        delete expr;
-}
-
-GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {}
-GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) {
-}
-GenericExpr::~GenericExpr() {
-        delete control;
-}
-
-void GenericExpr::print( std::ostream & os, Indenter indent ) const {
-        os << "C11 _Generic Expression" << std::endl << indent+1;
-        control->print( os, indent+1 );
-        os << std::endl << indent+1 << "... with associations: " << std::endl;
-        for ( const Association & assoc : associations ) {
-                os << indent+1;
-                if (assoc.isDefault) {
-                        os << "... default: ";
-                        assoc.expr->print( os, indent+1 );
-                } else {
-                        os << "... type: ";
-                        assoc.type->print( os, indent+1 );
-                        os << std::endl << indent+1 << "... expression: ";
-                        assoc.expr->print( os, indent+1 );
-                        os << std::endl;
-                }
-                os << std::endl;
-        }
-}
-
 // Local Variables: //
 // tab-width: 4 //