Changeset 4ee1efb for src/ResolvExpr

Timestamp:

Oct 26, 2017, 11:23:26 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct

Children:

136ccd7

Parents:

0b9be4d (diff), 598f50e (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.

git-author:

Rob Schluntz <rschlunt@…> (10/26/17 10:43:08)

git-committer:

Rob Schluntz <rschlunt@…> (10/26/17 11:23:26)

Message:

Merge branch 'fix-missing-cast-warning' into cleanup-dtors

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• AlternativeFinder.cc (modified) (7 diffs)
• Resolver.cc (modified) (1 diff)
• Unify.cc (modified) (3 diffs)

src/ResolvExpr/AdjustExprType.cc

@@ -28 +28 @@
                 void premutate( BasicType * ) { visit_children = false; }
                 void premutate( PointerType * ) { visit_children = false; }
+                void premutate( ArrayType * ) { visit_children = false; }
                 void premutate( FunctionType * ) { visit_children = false; }
                 void premutate( StructInstType * ) { visit_children = false; }
@@ -59 +60 @@
 
         Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
-                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
                 arrayType->base = nullptr;

src/ResolvExpr/AlternativeFinder.cc

@@ -180 +180 @@
                         throw SemanticError( "No reasonable alternatives for expression ", expr );
                 }
-                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
-                        if ( adjust ) {
-                                adjustExprType( i->expr->get_result(), i->env, indexer );
-                        }
-                }
                 if ( prune ) {
                         PRINT(
@@ -206 +201 @@
                                 std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
                         )
+                }
+                // adjust types after pruning so that types substituted by pruneAlternatives are correctly adjusted
+                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
+                        if ( adjust ) {
+                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                        }
                 }
 
@@ -318 +319 @@
         Cost computeExpressionConversionCost( Expression *& actualExpr, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
                 Cost convCost = computeConversionCost( actualExpr->result, formalType, indexer, env );
-                // if ( convCost != Cost::zero ) {
-
-                // xxx - temporary -- ignore poly cost, since this causes some polymorphic functions to be cast, which causes the specialize
-                // pass to try to specialize them, which currently does not work. Once that is fixed, remove the next 3 lines and uncomment the
-                // previous line.
+
+                // if there is a non-zero conversion cost, ignoring poly cost, then the expression requires conversion.
+                // ignore poly cost for now, since this requires resolution of the cast to infer parameters and this
+                // does not currently work for the reason stated below.
                 Cost tmpCost = convCost;
                 tmpCost.incPoly( -tmpCost.get_polyCost() );
                 if ( tmpCost != Cost::zero ) {
+                // if ( convCost != Cost::zero ) {
                         Type *newType = formalType->clone();
                         env.apply( newType );
@@ -631 +632 @@
                                         std::cerr << std::endl;
                                 )
-                                ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
                                 // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter).
-                                InferredParams * inferParameters = &appExpr->get_inferParams();
+                                InferredParams * inferParameters = &newerAlt.expr->get_inferParams();
                                 for ( UniqueId id : cur->second.idChain ) {
                                         inferParameters = (*inferParameters)[ id ].inferParams.get();
@@ -680 +680 @@
                 OpenVarSet openVars;
                 AssertionSet resultNeed, resultHave;
-                TypeEnvironment resultEnv;
+                TypeEnvironment resultEnv( func.env );
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 resultEnv.add( funcType->get_forall() ); // add all type variables as open variables now so that those not used in the parameter list are still considered open
@@ -914 +914 @@
                                 thisCost.incSafe( discardedValues );
                                 Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
-                                // xxx - this doesn't work at the moment, since inferParameters requires an ApplicationExpr as the alternative.
-                                // Once this works, it should be possible to infer parameters on a cast expression and specialize any function.
-
-                                // inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
-                                candidates.emplace_back( std::move( newAlt ) );
+                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
                         } // if
                 } // for
@@ -1297 +1293 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
+                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
                                 }
                         }

src/ResolvExpr/Resolver.cc

@@ -593 +593 @@
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
+                std::swap( initExpr->inferParams, newExpr->inferParams ) ;
                 delete initExpr;
 

src/ResolvExpr/Unify.cc

@@ -17 +17 @@
 #include <iterator>               // for back_insert_iterator, back_inserter
 #include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
-#include <memory>                 // for unique_ptr, auto_ptr
+#include <memory>                 // for unique_ptr
 #include <set>                    // for set
 #include <string>                 // for string, operator==, operator!=, bas...
@@ -170 +170 @@
                                 Type *common = 0;
                                 // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
-                                std::auto_ptr< Type > newType( curClass.type->clone() );
+                                std::unique_ptr< Type > newType( curClass.type->clone() );
                                 newType->get_qualifiers() = typeInst->get_qualifiers();
                                 if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
@@ -459 +459 @@
                 if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) {
 
-                        // not positive this is correct in all cases, but it's needed for typedefs
-                        if ( arrayType->get_isVarLen() || otherArray->get_isVarLen() ) {
-                                return;
-                        }
-
                         if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() &&
                                 arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0 ) {