Changeset eba74ba for src/ResolvExpr/Resolver.cc

Timestamp:

May 25, 2018, 2:51:06 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

cdc4d43

Parents:

3ef35bd (diff), 58e822a (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 remote-tracking branch 'origin/master' into with_gc

File:

• src/ResolvExpr/Resolver.cc (modified) (6 diffs)

src/ResolvExpr/Resolver.cc

@@ -128 +128 @@
 
         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
                 }
 
@@ -178 +197 @@
                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
                         if ( winners.size() == 0 ) {
-                                SemanticError( untyped, toString( 
-                                        "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), 
-                                        "expression: ") );
+                                SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
                         } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for " 
-                                        << kindStr << (kindStr != "" ? " " : "") << "expression\n";
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
                                 untyped->print( stream );
                                 stream << " Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
-                                
                                 SemanticError( untyped->location, stream.str() );
                         }
@@ -196 +211 @@
                         if ( findDeletedExpr( choice.expr ) ) {
                                 trace( choice.expr );
-                                SemanticError( choice.expr, 
-                                        "Unique best alternative includes deleted identifier in " );
+                                SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
                         }
                         alt = std::move( choice );
@@ -416 +430 @@
 
         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." );
@@ -422 +436 @@
                         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;
+                        // 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 );
+                        }
+                        caseStmt->condition = newExpr;
                 }
         }
@@ -719 +738 @@
                 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 );
 
                 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)