Changeset 8e9d567

Timestamp:

Aug 19, 2020, 2:09:04 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

03a4c73

Parents:

133a161 (diff), 13d33a75 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/TypeSubstitution.hpp (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/Unify.cc (modified) (3 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• Tuples/Explode.cc (modified) (1 diff)

src/AST/Convert.cpp

@@ -167 +167 @@
                         LinkageSpec::Spec( node->linkage.val ),
                         bfwd,
-                        type,
+                        type->clone(),
                         init,
                         attr,

src/AST/Print.cpp

@@ -237 +237 @@
         void postprint( const ast::Expr * node ) {
                 print( node->inferred );
+
+                if ( node->result ) {
+                        os << endl << indent << "... with resolved type:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->result->accept( *this );
+                        --indent;
+                }
 
                 if ( node->env ) {

src/AST/TypeSubstitution.hpp

@@ -195 +195 @@
         assert( input );
         Pass<Substituter> sub( *this, true );
-        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
+        input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) );
         return { input, sub.core.subCount };
 }

src/ResolvExpr/CandidateFinder.cpp

@@ -1473 +1473 @@
                                         // unification run for side-effects
                                         unify( toType, cand->expr->result, env, need, have, open, symtab );
-                                        Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                        Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
                                                         symtab, env );
 
@@ -1483 +1483 @@
                                                                 initExpr->location, restructureCast( cand->expr, toType ),
                                                                 initAlt.designation },
-                                                        copy( cand->env ), move( open ), move( need ), cand->cost, thisCost );
+                                                        move(env), move( open ), move( need ), cand->cost, thisCost );
                                                 inferParameters( newCand, matches );
                                         }

src/ResolvExpr/Unify.cc

@@ -791 +791 @@
                         for ( const ast::DeclWithType * d : src ) {
                                 ast::Pass<TtypeExpander_new> expander{ env };
-                                d = d->accept( expander );
-                                auto types = flatten( d->get_type() );
+                                // TtypeExpander pass is impure (may mutate nodes in place)
+                                // need to make nodes shared to prevent accidental mutation
+                                ast::ptr<ast::DeclWithType> dc = d;
+                                dc = dc->accept( expander );
+                                auto types = flatten( dc->get_type() );
                                 for ( ast::ptr< ast::Type > & t : types ) {
                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
@@ -801 +804 @@
                                         // requirements than a non-mutex function
                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
-                                        dst.emplace_back( new ast::ObjectDecl{ d->location, "", t } );
+                                        dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t } );
                                 }
                         }
@@ -1110 +1113 @@
 
                         ast::Pass<TtypeExpander_new> expander{ tenv };
-                        const ast::Type * flat = tuple->accept( expander );
-                        const ast::Type * flat2 = tuple2->accept( expander );
+
+                        ast::ptr<ast::TupleType> tuplec = tuple;
+                        ast::ptr<ast::TupleType> tuple2c = tuple2;
+                        const ast::Type * flat = tuplec->accept( expander );
+                        const ast::Type * flat2 = tuple2c->accept( expander );
 
                         auto types = flatten( flat );

src/SynTree/Expression.cc

@@ -69 +69 @@
 void Expression::print( std::ostream & os, Indenter indent ) const {
         printInferParams( inferParams, os, indent+1, 0 );
+
+        if ( result ) {
+                os << std::endl << indent << "with resolved type:" << std::endl;
+                os << (indent+1);
+                result->print( os, indent+1 );
+        }
 
         if ( env ) {

src/Tuples/Explode.cc

@@ -161 +161 @@
                         castAdded = false;
                         const ast::Type * newType = getReferenceBase( newNode->result );
-                        return new ast::CastExpr{ newNode->location, node, newType };
+                        return new ast::CastExpr{ newNode->location, newNode, newType };
                 }
                 return newNode;