Changeset 8e18b8e for src/ResolvExpr/Unify.cc

Timestamp:

May 31, 2018, 4:24:49 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

0182bfa, 1d7b0a8

Parents:

75308bcc

Message:

stop eagerly copying EqvClass? on lookup

File:

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

src/ResolvExpr/Unify.cc

@@ -19 +19 @@
 #include <set>                    // for set
 #include <string>                 // for string, operator==, operator!=, bas...
-#include <utility>                // for pair
+#include <utility>                // for pair, move
 
 #include "Common/PassVisitor.h"   // for PassVisitor
@@ -159 +159 @@
                         return false;
                 } // if
-                EqvClass curClass;
-                if ( env.lookup( typeInst->get_name(), curClass ) ) {
-                        if ( curClass.type ) {
+                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
+                        if ( curClass->type ) {
                                 Type *common = 0;
                                 // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
-                                Type* newType = curClass.type->clone();
+                                Type* newType = curClass->type->clone();
                                 newType->get_qualifiers() = typeInst->get_qualifiers();
-                                if ( unifyInexact( newType, other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
+                                if ( unifyInexact( newType, other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
                                         if ( common ) {
                                                 common->get_qualifiers() = Type::Qualifiers();
-                                                curClass.type = common;
-                                                env.add( curClass );
+                                                EqvClass newClass = *curClass;
+                                                newClass.type = common;
+                                                env.add( std::move(newClass) );
                                         } // if
                                         return true;
@@ -177 +177 @@
                                 } // if
                         } else {
-                                curClass.type = other->clone();
-                                curClass.type->get_qualifiers() = Type::Qualifiers();
-                                curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
-                                env.add( curClass );
+                                EqvClass newClass = *curClass;
+                                newClass.type = other->clone();
+                                newClass.type->get_qualifiers() = Type::Qualifiers();
+                                newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
+                                env.add( std::move(newClass) );
                         } // if
                 } else {
@@ -196 +197 @@
         bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 bool result = true;
-                EqvClass class1, class2;
-                bool hasClass1 = false, hasClass2 = false;
+                const EqvClass *class1 = env.lookup( var1->get_name() );
+                const EqvClass *class2 = env.lookup( var2->get_name() );
                 bool widen1 = false, widen2 = false;
-                Type *type1 = 0, *type2 = 0;
-
-                if ( env.lookup( var1->get_name(), class1 ) ) {
-                        hasClass1 = true;
-                        if ( class1.type ) {
-                                if ( occurs( class1.type, var2->get_name(), env ) ) {
+                Type *type1 = nullptr, *type2 = nullptr;
+
+                if ( class1 ) {
+                        if ( class1->type ) {
+                                if ( occurs( class1->type, var2->get_name(), env ) ) {
                                         return false;
                                 } // if
-                                type1 = class1.type->clone();
-                        } // if
-                        widen1 = widenMode.widenFirst && class1.allowWidening;
-                } // if
-                if ( env.lookup( var2->get_name(), class2 ) ) {
-                        hasClass2 = true;
-                        if ( class2.type ) {
-                                if ( occurs( class2.type, var1->get_name(), env ) ) {
+                                type1 = class1->type->clone();
+                        } // if
+                        widen1 = widenMode.widenFirst && class1->allowWidening;
+                } // if
+                if ( class2 ) {
+                        if ( class2->type ) {
+                                if ( occurs( class2->type, var1->get_name(), env ) ) {
                                         return false;
                                 } // if
-                                type2 = class2.type->clone();
-                        } // if
-                        widen2 = widenMode.widenSecond && class2.allowWidening;
+                                type2 = class2->type->clone();
+                        } // if
+                        widen2 = widenMode.widenSecond && class2->allowWidening;
                 } // if
 
@@ -227 +226 @@
                         Type *common = 0;
                         if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
-                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
-                                class1.allowWidening = widen1 && widen2;
+                                EqvClass newClass1 = *class1;
+                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
+                                newClass1.allowWidening = widen1 && widen2;
                                 if ( common ) {
                                         common->get_qualifiers() = Type::Qualifiers();
-                                        class1.type = common;
+                                        newClass1.type = common;
                                 } // if
-                                env.add( class1 );
+                                env.add( std::move(newClass1) );
                         } else {
                                 result = false;
                         } // if
-                } else if ( hasClass1 && hasClass2 ) {
+                } else if ( class1 && class2 ) {
                         if ( type1 ) {
-                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
-                                class1.allowWidening = widen1;
-                                env.add( class1 );
+                                EqvClass newClass1 = *class1;
+                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
+                                newClass1.allowWidening = widen1;
+                                env.add( std::move(newClass1) );
                         } else {
-                                class2.vars.insert( class1.vars.begin(), class1.vars.end() );
-                                class2.allowWidening = widen2;
-                                env.add( class2 );
-                        } // if
-                } else if ( hasClass1 ) {
-                        class1.vars.insert( var2->get_name() );
-                        class1.allowWidening = widen1;
-                        env.add( class1 );
-                } else if ( hasClass2 ) {
-                        class2.vars.insert( var1->get_name() );
-                        class2.allowWidening = widen2;
-                        env.add( class2 );
+                                EqvClass newClass2 = *class2;
+                                newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
+                                newClass2.allowWidening = widen2;
+                                env.add( std::move(newClass2) );
+                        } // if
+                } else if ( class1 ) {
+                        EqvClass newClass1 = *class1;
+                        newClass1.vars.insert( var2->get_name() );
+                        newClass1.allowWidening = widen1;
+                        env.add( std::move(newClass1) );
+                } else if ( class2 ) {
+                        EqvClass newClass2 = *class2;
+                        newClass2.vars.insert( var1->get_name() );
+                        newClass2.allowWidening = widen2;
+                        env.add( std::move(newClass2) );
                 } else {
                         EqvClass newClass;
@@ -521 +525 @@
                 void premutate( TypeInstType * ) { visit_children = false; }
                 Type * postmutate( TypeInstType * typeInst ) {
-                        EqvClass eqvClass;
-                        if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
-                                if ( eqvClass.data.kind == TypeDecl::Ttype ) {
-                                        // expand ttype parameter into its actual type
-                                        if ( eqvClass.type ) {
-                                                return eqvClass.type->clone();
-                                        }
+                        if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
+                                // expand ttype parameter into its actual type
+                                if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
+                                        return eqvClass->type->clone();
                                 }
                         }