Changeset af746cc for src/ResolvExpr/Unify.cc

Timestamp:

Apr 15, 2024, 12:03:53 PM (4 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

dc58e5d

Parents:

d9bad51

Message:

Reimplement the resolution of Enum instance type

File:

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

src/ResolvExpr/Unify.cc

@@ -274 +274 @@
                 void previsit( const ast::Node * ) { visit_children = false; }
 
-                void postvisit( const ast::VoidType * ) {
-                        result = dynamic_cast< const ast::VoidType * >( type2 );
+                void postvisit( const ast::VoidType * vt) {
+                        result = dynamic_cast< const ast::VoidType * >( type2 )
+                                || tryToUnifyWithEnumValue(vt, type2, tenv, need, have, open, noWiden());
+                        ;
                 }
 
@@ -282 +284 @@
                                 result = basic->kind == basic2->kind;
                         }
+                        result = result || tryToUnifyWithEnumValue(basic, type2, tenv, need, have, open, noWiden());
                 }
 
@@ -290 +293 @@
                                         noWiden());
                         }
+                        result = result || tryToUnifyWithEnumValue(pointer, type2, tenv, need, have, open, noWiden());
                 }
 
@@ -307 +311 @@
 
                         result = unifyExact(
-                                array->base, array2->base, tenv, need, have, open, noWiden());
+                                array->base, array2->base, tenv, need, have, open, noWiden())
+                                || tryToUnifyWithEnumValue(array, type2, tenv, need, have, open, noWiden());
                 }
 
@@ -399 +404 @@
                 }
 
+                bool tryToUnifyWithEnumValue( const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
+                        WidenMode widen) {
+                        if ( auto attrType2 = dynamic_cast<const ast::EnumAttrType *>(type2)) {
+                                if (attrType2->attr == ast::EnumAttribute::Value) {
+                                        return unifyExact( type1, attrType2->instance->base->base, env, need, have, open,
+                                                widen);
+                                } else if (attrType2->attr == ast::EnumAttribute::Posn) {
+                                        return unifyExact( type1, attrType2->instance, env, need, have, open, widen );
+                                }
+                        }
+                        return false;
+                }
+
         public:
                 void postvisit( const ast::FunctionType * func ) {
@@ -507 +526 @@
                 void postvisit( const ast::StructInstType * aggrType ) {
                         handleGenericRefType( aggrType, type2 );
+                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
                 }
 
                 void postvisit( const ast::UnionInstType * aggrType ) {
                         handleGenericRefType( aggrType, type2 );
+                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
                 }
 
                 void postvisit( const ast::EnumInstType * aggrType ) {
                         handleRefType( aggrType, type2 );
-                }
-
-                void postvisit( const ast::EnumPosType * posType ) {
+                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
+                }
+
+                void postvisit( const ast::EnumAttrType * enumAttr ) {
                         // Lazy approach for now
-                        auto otherPos = dynamic_cast< const ast::EnumPosType *>(type2);
-                        if ( otherPos ) {
-                                if ( otherPos->instance->base->name == posType->instance->base->name )
-                                        result = otherPos;
-                        }
+                        if ( auto otherPos = dynamic_cast< const ast::EnumAttrType *>(type2) ) {
+                            if ( enumAttr->match(otherPos) ) {
+                                    result = otherPos;
+                            }
+            }  
                 }
 
                 void postvisit( const ast::TraitInstType * aggrType ) {
                         handleRefType( aggrType, type2 );
+                        result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
                 }
 
@@ -536 +559 @@
                                 this->result = otherInst;
                         }
+                        result = result || tryToUnifyWithEnumValue(typeInst, type2, tenv, need, have, open, noWiden());
                 }
 
@@ -610 +634 @@
                         auto types2 = flatten( flat2 );
 
-                        result = unifyList( types, types2, tenv, need, have, open );
-                }
-
-                void postvisit( const ast::VarArgsType * ) {
-                        result = dynamic_cast< const ast::VarArgsType * >( type2 );
-                }
-
-                void postvisit( const ast::ZeroType * ) {
-                        result = dynamic_cast< const ast::ZeroType * >( type2 );
-                }
-
-                void postvisit( const ast::OneType * ) {
-                        result = dynamic_cast< const ast::OneType * >( type2 );
+                        result = unifyList( types, types2, tenv, need, have, open )
+                                || tryToUnifyWithEnumValue(tuple, type2, tenv, need, have, open, noWiden());
+                }
+
+                void postvisit( const ast::VarArgsType * vat) {
+                        result = dynamic_cast< const ast::VarArgsType * >( type2 )
+                                || tryToUnifyWithEnumValue(vat, type2, tenv, need, have, open, noWiden());
+                }
+
+                void postvisit( const ast::ZeroType * zt) {
+                        result = dynamic_cast< const ast::ZeroType * >( type2 )
+                                || tryToUnifyWithEnumValue(zt, type2, tenv, need, have, open, noWiden());
+                }
+
+                void postvisit( const ast::OneType * ot) {
+                        result = dynamic_cast< const ast::OneType * >( type2 )
+                                || tryToUnifyWithEnumValue(ot, type2, tenv, need, have, open, noWiden());
                 }
         };