Changeset fc1a3e2 for src/ResolvExpr

Timestamp:

Apr 19, 2024, 2:36:52 PM (3 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

ba97ebf

Parents:

b9b6efb

Message:

Style update. Focused on indentation and trailing whitespace.

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (2 diffs)
• CommonType.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (1 diff)
• 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/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;
+                                }
+                        }
                 }