Changeset e5d9274 for src/ResolvExpr/CommonType.cc

Timestamp:

Jun 2, 2022, 3:11:21 PM (3 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

ced5e2a

Parents:

015925a (diff), fc134a48 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/CommonType.cc (modified) (13 diffs)

src/ResolvExpr/CommonType.cc

@@ -497 +497 @@
                                 result = new BasicType( basicType->tq | otherBasic->tq, newType );
                         } // if
-                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
+                } else if (  dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
                         // use signed int in lieu of the enum/zero/one type
                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
@@ -503 +503 @@
                                 result = new BasicType( basicType->tq | type2->tq, newType );
                         } // if
-                } // if
+                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * > ( type2 ) ) {
+                        const EnumDecl* enumDecl = enumInst->baseEnum;
+                        if ( const Type* baseType = enumDecl->base ) {
+                                result = baseType->clone();
+                        } else {
+                                BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
+                                if ( ( ( newType == basicType->get_kind() && basicType->tq >= type2->tq ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->tq <= type2->tq ) || widenSecond ) ) {
+                                        result = new BasicType( basicType->tq | type2->tq, newType );
+                                } // if
+                        }
+                }
         }
 
@@ -691 +701 @@
                                 }
                         } else if (
-                                dynamic_cast< const ast::EnumInstType * >( type2 )
-                                || dynamic_cast< const ast::ZeroType * >( type2 )
+                                dynamic_cast< const ast::ZeroType * >( type2 )
                                 || dynamic_cast< const ast::OneType * >( type2 )
                         ) {
@@ -705 +714 @@
                                         result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
                                 }
+                        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
+                                #warning remove casts when `commonTypes` moved to new AST
+                                const ast::EnumDecl* enumDecl = enumInst->base;
+                                if ( enumDecl->base ) {
+                                        result = enumDecl->base.get();
+                                } else {
+                                        ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
+                                        if (
+                                                ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
+                                                        || widen.first )
+                                                && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+                                                        || widen.second )
+                                        ) {
+                                                result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+                                        }
+                                }
                         }
                 }
@@ -723 +748 @@
                         result = voidPtr;
                         add_qualifiers( result, oPtr->qualifiers );
+                }
+
+                // For a typed enum, we want to unify type1 with the base type of the enum
+                bool tryResolveWithTypedEnum( const ast::Type * type1 ) {
+                        if (auto enumInst = dynamic_cast<const ast::EnumInstType *> (type2) ) {
+                                ast::AssertionSet have, need; // unused
+                                ast::OpenVarSet newOpen{ open };
+                                if (enumInst->base->base 
+                                && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen, symtab)) {
+                                        result = type1;
+                                        return true;
+                                }
+                        }
+                        return false;
                 }
 
@@ -768 +807 @@
                                 result = pointer;
                                 add_qualifiers( result, type2->qualifiers );
-                        }
-                }
-
-                void postvisit( const ast::ArrayType * ) {}
+                        } else {
+                                tryResolveWithTypedEnum( pointer );
+                        }
+                }
+
+                void postvisit( const ast::ArrayType * arr ) {
+                        // xxx - does it make sense? 
+                        tryResolveWithTypedEnum( arr );
+                }
 
                 void postvisit( const ast::ReferenceType * ref ) {
@@ -810 +854 @@
                                 result = ref;
                                 add_qualifiers( result, type2->qualifiers );
-                        }
-                }
-
-                void postvisit( const ast::FunctionType * ) {}
-
-                void postvisit( const ast::StructInstType * ) {}
-
-                void postvisit( const ast::UnionInstType * ) {}
+                        } else {
+                                // xxx - does unifying a ref with typed enumInst makes sense?
+                                if (!dynamic_cast<const ast::EnumInstType *>(type2))
+                                        result = commonType( type2, ref, widen, symtab, tenv, open );
+                        }
+                }
+
+                void postvisit( const ast::FunctionType * func) {
+                        tryResolveWithTypedEnum( func ); 
+                }
+
+                void postvisit( const ast::StructInstType * inst ) {
+                        tryResolveWithTypedEnum( inst );
+                }
+
+                void postvisit( const ast::UnionInstType * inst ) {
+                        tryResolveWithTypedEnum( inst );
+                }
 
                 void postvisit( const ast::EnumInstType * enumInst ) {
-                        if (
-                                dynamic_cast< const ast::BasicType * >( type2 )
-                                || dynamic_cast< const ast::ZeroType * >( type2 )
-                                || dynamic_cast< const ast::OneType * >( type2 )
-                        ) {
-                                // reuse BasicType/EnumInstType common type by swapping
+                        // reuse BasicType/EnumInstType common type by swapping
+                        // xxx - is this already handled by unify?
+                        if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                 result = commonType( type2, enumInst, widen, symtab, tenv, open );
-                        }
                 }
 
@@ -850 +900 @@
                                                 result = type2;
                                                 reset_qualifiers( result, q1 | q2 );
+                                        } else {
+                                                tryResolveWithTypedEnum( t1 );
                                         }
                                 }
@@ -855 +907 @@
                 }
 
-                void postvisit( const ast::TupleType * ) {}
+                void postvisit( const ast::TupleType * tuple) {
+                        tryResolveWithTypedEnum( tuple );
+                }
 
                 void postvisit( const ast::VarArgsType * ) {}
@@ -861 +915 @@
                 void postvisit( const ast::ZeroType * zero ) {
                         if ( ! widen.first ) return;
-                        if (
-                                dynamic_cast< const ast::BasicType * >( type2 )
-                                || dynamic_cast< const ast::PointerType * >( type2 )
-                                || dynamic_cast< const ast::EnumInstType * >( type2 )
-                        ) {
+                        if ( dynamic_cast< const ast::BasicType * >( type2 )
+                                || dynamic_cast< const ast::PointerType * >( type2 ) ) {
                                 if ( widen.second || zero->qualifiers <= type2->qualifiers ) {
                                         result = type2;
@@ -873 +924 @@
                                 result = new ast::BasicType{
                                         ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers };
+                        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
+                                const ast::EnumDecl * enumDecl = enumInst->base;
+                                if ( enumDecl->base ) {
+                                        if ( tryResolveWithTypedEnum( zero ) ) 
+                                                add_qualifiers( result, zero->qualifiers );
+                                } else {
+                                        if ( widen.second || zero->qualifiers <= type2->qualifiers ) {
+                                                result = type2;
+                                                add_qualifiers( result, zero->qualifiers );
+                                        }
+                                }
                         }
                 }
@@ -878 +940 @@
                 void postvisit( const ast::OneType * one ) {
                         if ( ! widen.first ) return;
-                        if (
-                                dynamic_cast< const ast::BasicType * >( type2 )
-                                || dynamic_cast< const ast::EnumInstType * >( type2 )
-                        ) {
+                        if ( dynamic_cast< const ast::BasicType * >( type2 ) ) {
                                 if ( widen.second || one->qualifiers <= type2->qualifiers ) {
                                         result = type2;
@@ -889 +948 @@
                                 result = new ast::BasicType{
                                         ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers };
+                        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
+                                const ast::EnumDecl * enumBase = enumInst->base;
+                                if ( enumBase->base ) {
+                                        if ( tryResolveWithTypedEnum( one ))
+                                                add_qualifiers( result, one->qualifiers );
+                                } else {
+                                        if ( widen.second || one->qualifiers <= type2->qualifiers ) {
+                                                result = type2;
+                                                add_qualifiers( result, one->qualifiers );
+                                        }
+                                }
                         }
                 }