Changeset 4520b77e for src/ResolvExpr

Timestamp:

Sep 20, 2022, 8:37:05 PM (3 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

a065f1f

Parents:

d489da8 (diff), 12df6fe (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 to Master Sept 19

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (2 diffs)
• ConversionCost.cc (modified) (3 diffs)
• Resolver.cc (modified) (2 diffs)
• Unify.cc (modified) (2 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -864 +864 @@
                 }
 
+                void postvisit( const ast::QualifiedNameExpr * qualifiedNameExpr ) {
+                        auto mangleName = Mangle::mangle(qualifiedNameExpr->var);
+                        addCandidate( qualifiedNameExpr, tenv );
+                }
+
                 void postvisit( const ast::UntypedExpr * untypedExpr ) {
                         std::vector< CandidateFinder > argCandidates =
@@ -897 +902 @@
                                                 }
 
-                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
-                                                else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
-                                                        const ast::EnumDecl * enumDecl = enumInst->base;
-                                                        if ( const ast::Type* enumType = enumDecl->base ) {
-                                                                // instance of enum (T) is a instance of type (T)
-                                                                funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
-                                                        } else {
-                                                                // instance of an untyped enum is techically int
-                                                                funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
-                                                        }
-                                                }
+                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);                                             
+                                                // else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
+                                                //      const ast::EnumDecl * enumDecl = enumInst->base; // Here
+                                                //      if ( const ast::Type* enumType = enumDecl->base ) {
+                                                //              // instance of enum (T) is a instance of type (T) 
+                                                //              funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
+                                                //      } else {
+                                                //              // instance of an untyped enum is techically int
+                                                //              funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
+                                                //      }
+                                                // }
                                                 else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
                                         }

src/ResolvExpr/ConversionCost.cc

@@ -338 +338 @@
                 } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * >( dest ) ) {
                         const EnumDecl * base_enum = enumInst->baseEnum;
-                        if ( const Type * base = base_enum->base ) { // if the base enum has a base (if it is typed)
+                        if ( const Type * base = base_enum->base ) {
                                 if ( const BasicType * enumBaseAstBasic = dynamic_cast< const BasicType *> (base) ) {
                                         conversionCostFromBasicToBasic(basicType, enumBaseAstBasic);
@@ -632 +632 @@
         } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 const ast::EnumDecl * enumDecl = enumInst->base.get();
-                if ( const ast::Type * enumType = enumDecl->base.get() ) {
+                if ( enumDecl->isTyped && !enumDecl->base.get() ) {
+                        cost = Cost::infinity; 
+                } else if ( const ast::Type * enumType = enumDecl->base.get() ) {
                         if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
                                 conversionCostFromBasicToBasic( basicType, enumTypeAsBasic );
@@ -694 +696 @@
         const ast::EnumDecl * baseEnum = enumInstType->base;
         if ( const ast::Type * baseType = baseEnum->base ) {
-                cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
+                costCalc( baseType, dst, srcIsLvalue, symtab, env );
         } else {
                 (void)enumInstType;

src/ResolvExpr/Resolver.cc

@@ -1478 +1478 @@
                         // enum type is still incomplete at this point. Use `int` instead.
 
-                        if (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base) {
+                        if ( auto enumBase = dynamic_cast< const ast::EnumInstType * >
+                                ( objectDecl->get_type() )->base->base ) {
                                 objectDecl = fixObjectType( objectDecl, context );
-                                const ast::Type * enumBase =  (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base.get());
                                 currentObject = ast::CurrentObject{ 
                                         objectDecl->location, 
@@ -1493 +1493 @@
                 }
                 else {
-                        if (!objectDecl->isTypeFixed) {
+                        if ( !objectDecl->isTypeFixed ) {
                                 auto newDecl = fixObjectType(objectDecl, context);
                                 auto mutDecl = mutate(newDecl);

src/ResolvExpr/Unify.cc

@@ -165 +165 @@
                 ast::Type * newFirst  = shallowCopy( first  );
                 ast::Type * newSecond = shallowCopy( second );
+                if ( auto temp = dynamic_cast<const ast::EnumInstType *>(first) ) {
+                        if ( !dynamic_cast< const ast::EnumInstType * >( second ) ) {
+                                const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
+                                if ( auto t = baseEnum->base.get() ) {
+                                        newFirst = ast::shallowCopy( t );
+                                }
+                        }
+                } else if ( auto temp = dynamic_cast<const ast::EnumInstType *>(second) ) {
+                        const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
+                        if ( auto t = baseEnum->base.get() ) {
+                                newSecond = ast::shallowCopy( t );
+                        }
+                }
+
                 newFirst ->qualifiers = {};
                 newSecond->qualifiers = {};
@@ -988 +1002 @@
                                 if ( isTuple && isTuple2 ) {
                                         ++it; ++jt;  // skip ttype parameters before break
-                                } else if ( isTuple ) {
+                                } else if ( isTuple ) { 
                                         // bundle remaining params into tuple
                                         pty2 = tupleFromExprs( param2, jt, params2.end(), pty->qualifiers );