Changes in src/ResolvExpr/Unify.cc [f02f546:251ce80]

File:

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

src/ResolvExpr/Unify.cc

@@ -32 +32 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/Eval.h"            // for eval
 #include "Common/PassVisitor.h"     // for PassVisitor
 #include "CommonType.hpp"           // for commonType
@@ -161 +160 @@
                 env.apply( newSecond );
 
-                // findOpenVars( newFirst, open, closed, need, have, FirstClosed );
-                findOpenVars( newSecond, open, closed, need, have, newEnv, FirstOpen );
+                findOpenVars( newFirst, open, closed, need, have, FirstClosed );
+                findOpenVars( newSecond, open, closed, need, have, FirstOpen );
 
                 return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
@@ -780 +779 @@
         }
 
-        // Unification of Expressions
-        //
-        // Boolean outcome (obvious):  Are they basically spelled the same?
-        // Side effect of binding variables (subtle):  if `sizeof(int)` ===_expr `sizeof(T)` then `int` ===_ty `T`
-        //
-        // Context:  if `float[VAREXPR1]` ===_ty `float[VAREXPR2]` then `VAREXPR1` ===_expr `VAREXPR2`
-        // where the VAREXPR are meant as notational metavariables representing the fact that unification always
-        // sees distinct ast::VariableExpr objects at these positions
-
-        static bool unify( const ast::Expr * e1, const ast::Expr * e2, ast::TypeEnvironment & env,
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                WidenMode widen );
-
-        class UnifyExpr final : public ast::WithShortCircuiting {
-                const ast::Expr * e2;
-                ast::TypeEnvironment & tenv;
-                ast::AssertionSet & need;
-                ast::AssertionSet & have;
-                const ast::OpenVarSet & open;
-                WidenMode widen;
-        public:
-                bool result;
-
-        private:
-
-                void tryMatchOnStaticValue( const ast::Expr * e1 ) {
-                        Evaluation r1 = eval(e1);
-                        Evaluation r2 = eval(e2);
-
-                        if ( ! r1.hasKnownValue ) return;
-                        if ( ! r2.hasKnownValue ) return;
-
-                        if (r1.knownValue != r2.knownValue) return;
-
-                        visit_children = false;
-                        result = true;
-                }
-
-        public:
-
-                void previsit( const ast::Node * ) { assert(false); }
-
-                void previsit( const ast::Expr * e1 ) {
-                        tryMatchOnStaticValue( e1 );
-                        visit_children = false;
-                }
-
-                void previsit( const ast::CastExpr * e1 ) {
-                        tryMatchOnStaticValue( e1 );
-
-                        if (result) {
-                                assert (visit_children == false);
-                        } else {
-                                assert (visit_children == true);
-                                visit_children = false;
-
-                                auto e2c = dynamic_cast< const ast::CastExpr * >( e2 );
-                                if ( ! e2c ) return;
-
-                                // inspect casts' target types
-                                if ( ! unifyExact(
-                                        e1->result, e2c->result, tenv, need, have, open, widen ) ) return;
-
-                                // inspect casts' inner expressions
-                                result = unify( e1->arg, e2c->arg, tenv, need, have, open, widen );
-                        }
-                }
-
-                void previsit( const ast::VariableExpr * e1 ) {
-                        tryMatchOnStaticValue( e1 );
-
-                        if (result) {
-                                assert (visit_children == false);
-                        } else {
-                                assert (visit_children == true);
-                                visit_children = false;
-
-                                auto e2v = dynamic_cast< const ast::VariableExpr * >( e2 );
-                                if ( ! e2v ) return;
-
-                                assert(e1->var);
-                                assert(e2v->var);
-
-                                // conservative: variable exprs match if their declarations are represented by the same C++ AST object
-                                result = (e1->var == e2v->var);
-                        }
-                }
-
-                void previsit( const ast::SizeofExpr * e1 ) {
-                        tryMatchOnStaticValue( e1 );
-
-                        if (result) {
-                                assert (visit_children == false);
-                        } else {
-                                assert (visit_children == true);
-                                visit_children = false;
-
-                                auto e2so = dynamic_cast< const ast::SizeofExpr * >( e2 );
-                                if ( ! e2so ) return;
-
-                                assert((e1->type != nullptr) ^ (e1->expr != nullptr));
-                                assert((e2so->type != nullptr) ^ (e2so->expr != nullptr));
-                                if ( ! (e1->type && e2so->type) )  return;
-
-                                // expression unification calls type unification (mutual recursion)
-                                result = unifyExact( e1->type, e2so->type, tenv, need, have, open, widen );
-                        }
-                }
-
-                UnifyExpr( const ast::Expr * e2, ast::TypeEnvironment & env, ast::AssertionSet & need,
-                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen )
-                : e2( e2 ), tenv(env), need(need), have(have), open(open), widen(widen), result(false) {}
-        };
-
-        static bool unify( const ast::Expr * e1, const ast::Expr * e2, ast::TypeEnvironment & env,
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                WidenMode widen ) {
-                assert( e1 && e2 );
-                return ast::Pass<UnifyExpr>::read( e1, e2, env, need, have, open, widen );
-        }
-
         class Unify_new final : public ast::WithShortCircuiting {
                 const ast::Type * type2;
@@ -942 +820 @@
                         if ( ! array2 ) return;
 
+                        // to unify, array types must both be VLA or both not VLA and both must have a
+                        // dimension expression or not have a dimension
                         if ( array->isVarLen != array2->isVarLen ) return;
-                        if ( (array->dimension != nullptr) != (array2->dimension != nullptr) ) return;
-
-                        if ( array->dimension ) {
-                                assert( array2->dimension );
-                                // type unification calls expression unification (mutual recursion)
-                                if ( ! unify(array->dimension, array2->dimension,
-                                    tenv, need, have, open, widen) ) return;
+                        if ( ! array->isVarLen && ! array2->isVarLen
+                                        && array->dimension && array2->dimension ) {
+                                auto ce1 = array->dimension.as< ast::ConstantExpr >();
+                                auto ce2 = array2->dimension.as< ast::ConstantExpr >();
+
+                                // see C11 Reference Manual 6.7.6.2.6
+                                // two array types with size specifiers that are integer constant expressions are
+                                // compatible if both size specifiers have the same constant value
+                                if ( ce1 && ce2 && ce1->intValue() != ce2->intValue() ) return;
                         }
 
@@ -1082 +964 @@
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const XInstType * >( other );
-                        if (otherInst && inst->name == otherInst->name) 
-                                this->result = otherInst;
+                        if (otherInst && inst->name == otherInst->name) this->result = otherInst;
                         return otherInst;
                 }
@@ -1168 +1049 @@
 
                 void postvisit( const ast::TypeInstType * typeInst ) {
-                        // assert( open.find( *typeInst ) == open.end() );
-                        auto otherInst = dynamic_cast< const ast::TypeInstType * >( type2 );
-                        if (otherInst && typeInst->name == otherInst->name) 
-                                this->result = otherInst;
-                        // return otherInst;
+                        assert( open.find( *typeInst ) == open.end() );
+                        handleRefType( typeInst, type2 );
                 }
 
@@ -1283 +1161 @@
         ) {
                 ast::OpenVarSet closed;
-                // findOpenVars( type1, open, closed, need, have, FirstClosed );
-                findOpenVars( type2, open, closed, need, have, env, FirstOpen );
+                findOpenVars( type1, open, closed, need, have, FirstClosed );
+                findOpenVars( type2, open, closed, need, have, FirstOpen );
                 return unifyInexact(
                         type1, type2, env, need, have, open, WidenMode{ true, true }, common );
@@ -1301 +1179 @@
                         entry1 = var1 ? open.find( *var1 ) : open.end(),
                         entry2 = var2 ? open.find( *var2 ) : open.end();
-                // bool isopen1 = entry1 != open.end();
-                // bool isopen2 = entry2 != open.end();
-                bool isopen1 = var1 && env.lookup(*var1);
-                bool isopen2 = var2 && env.lookup(*var2);
-
-                /*
+                bool isopen1 = entry1 != open.end();
+                bool isopen2 = entry2 != open.end();
+
                 if ( isopen1 && isopen2 ) {
                         if ( entry1->second.kind != entry2->second.kind ) return false;
@@ -1315 +1190 @@
                         return env.bindVar( var1, type2, entry1->second, need, have, open, widen );
                 } else if ( isopen2 ) {
-                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
-                } */
-                if ( isopen1 && isopen2 ) {
-                        if ( var1->base->kind != var2->base->kind ) return false;
-                        return env.bindVarToVar(
-                                var1, var2, ast::TypeData{ var1->base->kind, var1->base->sized||var2->base->sized }, need, have,
-                                open, widen );
-                } else if ( isopen1 ) {
-                        return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen );
-                } else if ( isopen2 ) {
-                        return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
-                }else {
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen );
+                } else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen );
                 }
-                
         }