Changeset 5c14030 for src/ResolvExpr

Timestamp:

Jul 11, 2018, 4:26:22 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env

Children:

d318a18

Parents:

184557e

git-author:

Aaron Moss <a3moss@…> (07/11/18 16:10:36)

git-committer:

Aaron Moss <a3moss@…> (07/11/18 16:26:22)

Message:

Persistent-array environment compiles

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (8 diffs)
• TypeEnvironment.cc (modified) (14 diffs)
• TypeEnvironment.h (modified) (4 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -454 +454 @@
                 }
 
-                #if 0 // cost of assertions accounted for in function creation
+                #if 1 // cost of assertions accounted for in function creation
                 for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
                         convCost += computeConversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
@@ -584 +584 @@
         }
 
+#if !1
         namespace {
                 /// Information required to defer resolution of an expression
@@ -700 +701 @@
                 }
         }
+#endif
 
         template< typename OutputIterator >
@@ -715 +717 @@
                 // )
                 addToIndexer( have, decls );
-
+#if !1
                 AssertionResnState resn{ newAlt, openVars, indexer };
 
@@ -752 +754 @@
                 *out++ = newAlt;
 
-#if 0           
+#else           
                 AssertionSet newNeed;
                 PRINT(
@@ -1093 +1095 @@
         }
 
+#if !1
         namespace {
 
@@ -1230 +1233 @@
                 }
         }
+#endif
 
         template<typename OutputIterator>
@@ -1276 +1280 @@
 
                 // calculate declaration cost of function (+vars-spec)
+#if !1
                 Cost funcCost = declCost( funcType );
+#else
+                Cost funcCost = Cost::zero;
+#endif
 
                 // iteratively build matches, one parameter at a time

src/ResolvExpr/TypeEnvironment.cc

@@ -27 +27 @@
 #include "SynTree/Type.h"              // for Type, FunctionType, Type::Fora...
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
+#include "Tuples/Tuples.h"             // for isTtype
 #include "TypeEnvironment.h"
 #include "typeops.h"                   // for occurs
@@ -104 +105 @@
                 auto tyVar = openVars.find( typeInst->get_name() );
                 assert( tyVar != openVars.end() );
-                if ( ! tyVarCompatible( tyVar->second, other ) ) return false;
+                if ( ! tyVarCompatible( tyVar->second, bindTo ) ) return false;
 
                 if ( occurs( bindTo, typeInst->get_name(), *this ) ) return false;
@@ -135 +136 @@
                 } else {
                         // make new class consisting entirely of this variable
-                        BoundType curData{ bindTo->clone(), widenMode.first && widenMode.second, data };
+                        BoundType curData{ 
+                                bindTo->clone(), widenMode.widenFirst && widenMode.widenSecond, data };
                         curData.type->get_qualifiers() = Type::Qualifiers{};
                         classes = classes->add( curClass.get_root() );
@@ -146 +148 @@
                         const TypeDecl::Data& data, AssertionSet& need, AssertionSet& have, 
                         const OpenVarSet& openVars, WidenMode widenMode, const SymTab::Indexer& indexer ) {
-                ClassRef class1 = env.lookup( var1->get_name() );
-                ClassRef class2 = env.lookup( var2->get_name() );
+                ClassRef class1 = lookup( var1->get_name() );
+                ClassRef class2 = lookup( var2->get_name() );
                 
                 // exit early if variables already bound together
@@ -153 +155 @@
                         BoundType data1 = class1.get_bound();
                         // narrow the binding if needed
-                        if ( data1.allowWidening && widenMode.first != widenMode.second ) {
+                        if ( data1.allowWidening && widenMode.widenFirst != widenMode.widenSecond ) {
                                 data1.allowWidening = false;
                                 bindings = bindings->set( class1.get_root(), data1 );
@@ -172 +174 @@
                                         openVars, WidenMode{ widen1, widen2 }, indexer, common ) ) {
                                 // merge type variables
-                                interned_string root = mergeClasses( class1.update_root(), class2.update_root() );
+                                interned_string root = 
+                                        mergeClasses( class1.update_root(), class2.update_root() ).first;
                                 // update bindings
                                 data1.allowWidening = widen1 && widen2;
@@ -197 +200 @@
                                 if ( data2.allowWidening != widen2 ) {
                                         data2.allowWidening = widen2;
-                                        bindings = bindings->set( root, data2 );
+                                        bindings = bindings->set( merged.first, data2 );
                                 } else if ( merged.first == class1.get_root() ) {
                                         bindings = bindings->set( merged.first, data2 );
@@ -249 +252 @@
                         // filter overlapping classes out of existing environment
                         // (this is a very shady assumption, but has worked for a long time...)
-                        interned_string root = classes->find_or_default( v, not_found );
+                        interned_string root = classes->find_or_default( var, not_found );
                         if ( root != not_found ) {
                                 classes = classes->remove_class( root );
@@ -262 +265 @@
                         // add variable to class and bindings
                         classes = classes->add( var );
-                        bindings = bindings->set( var, BoundType{ p.second->clone, false, data } );
+                        bindings = bindings->set( var, BoundType{ p.second->clone(), false, data } );
                 }
         }
 
         void TypeEnvironment::makeSubstitution( TypeSubstitution &sub ) const {
-                bindings->apply_to_all([classes, &sub]( interned_string root, const BoundType& bound ){
-                        classes->apply_to_class(root, [&]( interned_string var ) {
+                bindings->for_each([&]( interned_string root, const BoundType& bound ){
+                        classes->for_class(root, [&]( interned_string var ) {
                                 if ( bound.type ) {
                                         sub.add( var, bound.type );
@@ -282 +285 @@
 
         void TypeEnvironment::print( std::ostream &os, Indenter indent ) const {
-                bindings->apply_to_all([classes,&]( interned_string root, const BoundType& bound ) {
+                bindings->for_each([&]( interned_string root, const BoundType& bound ) {
                         os << "( ";
-                        classes->apply_to_class( root, [&os]( interned_string var ) { os << var << " "; } );
+                        classes->for_class( root, [&os]( interned_string var ) { os << var << " "; } );
                         os << ")";
                         if ( bound.type ) {
                                 os << " -> ";
-                                type->print( os, indent+1 );
+                                bound.type->print( os, indent+1 );
                         }
                         if ( ! bound.allowWidening ) {
@@ -298 +301 @@
 
         void TypeEnvironment::simpleCombine( const TypeEnvironment &o ) {
-                o.bindings->apply_to_all( [&]( interned_string root, const BoundType& bound ) {
+                o.bindings->for_each( [&]( interned_string root, const BoundType& bound ) {
                         // add members of new class
                         interned_string new_root{nullptr};
-                        o.classes->apply_to_class( root, [this,&new_root]( interned_string var ) {
+                        o.classes->for_class( root, [this,&new_root]( interned_string var ) {
                                 classes = classes->add( var );
                                 new_root = new_root ? mergeClasses( new_root, var ).first : var;
@@ -311 +314 @@
 
         void TypeEnvironment::extractOpenVars( OpenVarSet &openVars ) const {
-                bindings->apply_to_all( [classes,&openVars]( interned_string root, const BoundType& bound ) {
-                        classes->apply_to_class( root, [&openVars,&bound]( interned_string var ) {
+                bindings->for_each( [&]( interned_string root, const BoundType& bound ) {
+                        classes->for_class( root, [&openVars,&bound]( interned_string var ) {
                                 openVars[ var ] = bound.data;
                         } );
@@ -319 +322 @@
 
         void TypeEnvironment::addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars ) {
-                actualEnv.bindings->apply_to_all( [&]( interned_string root, const BoundType& bound ) {
+                actualEnv.bindings->for_each( [&]( interned_string root, const BoundType& bound ) {
                         // add members of new class, setting openVars concurrently
                         interned_string new_root{nullptr};
-                        actualEnv.classes->apply_to_class( root, [&]( interned_string var ) {
+                        actualEnv.classes->for_class( root, [&]( interned_string var ) {
                                 classes = classes->add( var );
                                 new_root = new_root ? mergeClasses( new_root, var ).first : var;
@@ -334 +337 @@
 
         void TypeEnvironment::forbidWidening() {
-                bindings = bindings->apply_to_all([]( const interned_string& k, BoundType& c ) {
+                bindings = bindings->mutate_each([]( const interned_string&, BoundType& c ) {
                         if ( c.allowWidening ) {
                                 option<BoundType> ret = c;

src/ResolvExpr/TypeEnvironment.h

@@ -189 +189 @@
                 /// returned root variable will be valid regardless
                 ClassRef lookup( interned_string var ) const;
-                ClassRef lookup( const std::string &var ) const { return lookup( var ); }
 
                 /// Binds a type variable to a type; returns false if fails
@@ -202 +201 @@
 
         public:
+                TypeEnvironment() : classes{ new Classes{} }, bindings{ new Bindings{} } {}
+
                 void add( const Type::ForallList &tyDecls );
                 void add( const TypeSubstitution & sub );
@@ -224 +225 @@
                 void forbidWidening();
 
-                iterator begin() { return { this, bindings->begin() }; }
-                iterator end() { return { this, bindings->end() }; }
+                iterator begin() const { return { this, bindings->begin() }; }
+                iterator end() const { return { this, bindings->end() }; }
         };
 
@@ -234 +235 @@
                 T vars;
                 if ( ! env->classes->count( root ) ) return vars;
-                env->classes->apply_to_class( root, [&vars]( interned_string var ) {
+                env->classes->for_class( root, [&vars]( interned_string var ) {
                         vars.insert( vars.end(), var );
                 } );