Changeset 15215f02 for src/ResolvExpr

Timestamp:

Apr 22, 2024, 11:37:36 PM (5 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

13de4478

Parents:

0fe07be (diff), d7c0ad5 (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

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (2 diffs)
• CommonType.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (1 diff)
• PolyCost.cc (modified) (2 diffs)
• Unify.cc (modified) (3 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -1412 +1412 @@
         }
 
-    void Finder::postvisit(const ast::VariableExpr *variableExpr) {
-        // not sufficient to just pass `variableExpr` here, type might have changed
-
-        auto cand = new Candidate(variableExpr, tenv);
-        candidates.emplace_back(cand);
-    }
+        void Finder::postvisit(const ast::VariableExpr *variableExpr) {
+                // not sufficient to just pass `variableExpr` here, type might have changed
+
+                auto cand = new Candidate(variableExpr, tenv);
+                candidates.emplace_back(cand);
+        }
 
         void Finder::postvisit( const ast::ConstantExpr * constantExpr ) {
@@ -2133 +2133 @@
 
 // get the valueE(...) ApplicationExpr that returns the enum value
-const ast::Expr * getValueEnumCall( 
-        const ast::Expr * expr, 
+const ast::Expr * getValueEnumCall(
+        const ast::Expr * expr,
         const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env ) {
                 auto callExpr = new ast::UntypedExpr(

src/ResolvExpr/CommonType.cc

@@ -397 +397 @@
                         }
                 } else if ( auto type2AsAttr = dynamic_cast< const ast::EnumAttrType * >( type2 ) ) {
-            if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
-                            ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::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 };
-                            }
-            }
+                        if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
+                                ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::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 };
+                                }
+                        }
                 }
         }
@@ -519 +519 @@
                                                                 // xxx - assume LHS is always the target type
 
-                                                                if ( ! ((widen.second && ref2->qualifiers.is_mutex) 
+                                                                if ( ! ((widen.second && ref2->qualifiers.is_mutex)
                                                                 || (ref1->qualifiers.is_mutex == ref2->qualifiers.is_mutex ))) return;
 

src/ResolvExpr/ConversionCost.cc

@@ -379 +379 @@
 
 void ConversionCost::postvisit( const ast::EnumAttrType * src ) {
-    auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
+        auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
         assert( src->attr != ast::EnumAttribute::Label );
-    if ( src->attr == ast::EnumAttribute::Value ) {
-        if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
-            cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
-        } else {
-            auto baseType = src->instance->base->base;
-            cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
+        if ( src->attr == ast::EnumAttribute::Value ) {
+                if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
+                        cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
+                } else {
+                        auto baseType = src->instance->base->base;
+                        cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
                         if ( cost < Cost::infinity ) {
                                 cost.incUnsafe();
                         }
-        }
-    } else { // ast::EnumAttribute::Posn
-        if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-                    cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
-                    if ( cost < Cost::unsafe ) cost.incSafe();
-            } else {
-                    static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-                    cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-                    if ( cost < Cost::unsafe ) {
-                            cost.incSafe();
-                    }
-            }
-    }
+                }
+        } else { // ast::EnumAttribute::Posn
+                if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
+                        cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
+                        if ( cost < Cost::unsafe ) cost.incSafe();
+                } else {
+                        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
+                        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+                        if ( cost < Cost::unsafe ) {
+                                cost.incSafe();
+                        }
+                }
+        }
 }
 

src/ResolvExpr/PolyCost.cc

@@ -29 +29 @@
         const ast::TypeEnvironment &env_;
 
-        PolyCost( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) 
+        PolyCost( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env )
         : symtab( symtab ), result( 0 ), env_( env ) {}
 
         void previsit( const ast::TypeInstType * type ) {
-                if ( const ast::EqvClass * eqv = env_.lookup( *type ) ) /* && */ if ( eqv->bound ) {
+                if ( const ast::EqvClass * eqv = env_.lookup( *type ) ; eqv && eqv->bound ) {
                         if ( const ast::TypeInstType * otherType = eqv->bound.as< ast::TypeInstType >() ) {
                                 if ( symtab.lookupType( otherType->name ) ) {
                                         // Bound to opaque type.
-                                        result += 1;
+                                        result = 1;
                                 }
                         } else {
                                 // Bound to concrete type.
-                                result += 1;
+                                result = 1;
                         }
                 }
@@ -52 +52 @@
         const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
-        ast::Pass<PolyCost> costing( symtab, env );
-        type->accept( costing );
-        return (costing.core.result > 0) ? 1 : 0;
+        return ast::Pass<PolyCost>::read( type, symtab, env );
 }
 

src/ResolvExpr/Unify.cc

@@ -307 +307 @@
                                 // type unification calls expression unification (mutual recursion)
                                 if ( ! unify(array->dimension, array2->dimension,
-                                    tenv, need, have, open, widen) ) return;
+                                        tenv, need, have, open, widen) ) return;
                         }
 
@@ -455 +455 @@
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const XInstType * >( other );
-                        if (otherInst && inst->name == otherInst->name) 
+                        if (otherInst && inst->name == otherInst->name)
                                 this->result = otherInst;
                         return otherInst;
@@ -542 +542 @@
                         // Lazy approach for now
                         if ( auto otherPos = dynamic_cast< const ast::EnumAttrType *>(type2) ) {
-                            if ( enumAttr->match(otherPos) ) {
-                                    result = otherPos;
-                            }
-            }  
+                                if ( enumAttr->match(otherPos) ) {
+                                        result = otherPos;
+                                }
+                        }
                 }