Changeset 5c14030 for src/ResolvExpr/TypeEnvironment.cc

Timestamp:

Jul 11, 2018, 4:26:22 PM (6 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

File:

• src/ResolvExpr/TypeEnvironment.cc (modified) (14 diffs)

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;