Changeset cdb990a

Timestamp:

May 18, 2018, 6:45:18 PM (6 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, with_gc

Children:

ccdab45

Parents:

95642c9

git-author:

Rob Schluntz <rschlunt@…> (05/18/18 18:04:11)

git-committer:

Rob Schluntz <rschlunt@…> (05/18/18 18:45:18)

Message:

Strip redundant casts after every resolution

Location:

src

Files:

• ResolvExpr/Resolver.cc (modified) (4 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)

src/ResolvExpr/Resolver.cc

@@ -127 +127 @@
 
         namespace {
-                void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                struct StripCasts {
+                        Expression * postmutate( CastExpr * castExpr ) {
+                                if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
+                                        // generated cast is to the same type as its argument, so it's unnecessary -- remove it
+                                        Expression * expr = castExpr->arg;
+                                        castExpr->arg = nullptr;
+                                        std::swap( expr->env, castExpr->env );
+                                        return expr;
+                                }
+                                return castExpr;
+                        }
+
+                        static void strip( Expression *& expr ) {
+                                PassVisitor<StripCasts> stripper;
+                                expr = expr->acceptMutator( stripper );
+                        }
+                };
+
+                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
-                        env.makeSubstitution( *expr->get_env() );
+                        env.makeSubstitution( *expr->env );
+                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
                 }
 
@@ -414 +433 @@
 
         void Resolver::previsit( CaseStmt *caseStmt ) {
-                if ( caseStmt->get_condition() ) {
+                if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
@@ -420 +439 @@
                         Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
                         findSingleExpression( newExpr, indexer );
-                        CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
-                        caseStmt->condition = castExpr->arg;
-                        castExpr->arg = nullptr;
-                        delete castExpr;
+                        // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
+                        // Ideally we would perform the conversion internally here.
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                newExpr = castExpr->arg;
+                                castExpr->arg = nullptr;
+                                std::swap( newExpr->env, castExpr->env );
+                                delete castExpr;
+                        }
+                        caseStmt->condition = newExpr;
                 }
         }
@@ -718 +742 @@
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
-                std::swap( initExpr->inferParams, newExpr->inferParams ) ;
+                // InitExpr may have inferParams in the case where the expression specializes a function pointer,
+                // and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
+                newExpr->spliceInferParams( initExpr );
                 delete initExpr;
 

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;

src/SynTree/Expression.h

@@ -76 +76 @@
         InferredParams & get_inferParams() { return inferParams; }
 
+        // move other's inferParams to this
+        void spliceInferParams( Expression * other );
+
         virtual Expression * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;