Changeset 7a80113 for src/ResolvExpr

Timestamp:

Sep 22, 2020, 11:29:12 AM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct

Children:

0a945fd

Parents:

1c507eb (diff), 08f3ad3 (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)
• ConversionCost.cc (modified) (2 diffs)
• ConversionCost.h (modified) (1 diff)
• CurrentObject.cc (modified) (3 diffs)
• Resolver.cc (modified) (6 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -816 +816 @@
                 /// Adds aggregate member interpretations
                 void addAggMembers(
-                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
+                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
                         const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
@@ -1263 +1263 @@
 
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
-                        const ast::ReferenceToType * aggInst;
+                        const ast::BaseInstType * aggInst;
                         if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
                         else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;

src/ResolvExpr/ConversionCost.cc

@@ -520 +520 @@
                 return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
         } else {
-                ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
-                src->accept( converter );
-                return converter.core.cost;
+                return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
         }
 }
@@ -563 +561 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
-                        src->accept( converter );
-                        return converter.core.cost;
+                        return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
                 }
         } else {

src/ResolvExpr/ConversionCost.h

@@ -88 +88 @@
         static size_t traceId;
         Cost cost;
+        Cost result() { return cost; }
 
         ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,

src/ResolvExpr/CurrentObject.cc

@@ -923 +923 @@
 
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
-                if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
+                if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
                                 return new StructIterator{ loc, sit };
@@ -932 +932 @@
                                         dynamic_cast< const EnumInstType * >( type )
                                                 || dynamic_cast< const TypeInstType * >( type ),
-                                        "Encountered unhandled ReferenceToType in createMemberIterator: %s",
+                                        "Encountered unhandled BaseInstType in createMemberIterator: %s",
                                                 toString( type ).c_str() );
                                 return new SimpleIterator{ loc, type };
@@ -965 +965 @@
                                         DesignatorChain & d = *dit;
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
-                                        if ( auto refType = dynamic_cast< const ReferenceToType * >( t ) ) {
+                                        if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
                                                 // concatenate identical field names
                                                 for ( const Decl * mem : refType->lookup( nexpr->name ) ) {

src/ResolvExpr/Resolver.cc

@@ -38 +38 @@
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
+#include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "InitTweak/GenInit.h"
@@ -965 +966 @@
                 /// Finds deleted expressions in an expression tree
                 struct DeleteFinder_new final : public ast::WithShortCircuiting {
-                        const ast::DeletedExpr * delExpr = nullptr;
+                        const ast::DeletedExpr * result = nullptr;
 
                         void previsit( const ast::DeletedExpr * expr ) {
-                                if ( delExpr ) { visit_children = false; }
-                                else { delExpr = expr; }
+                                if ( result ) { visit_children = false; }
+                                else { result = expr; }
                         }
 
                         void previsit( const ast::Expr * ) {
-                                if ( delExpr ) { visit_children = false; }
+                                if ( result ) { visit_children = false; }
                         }
                 };
@@ -980 +981 @@
         /// Check if this expression is or includes a deleted expression
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
-                ast::Pass<DeleteFinder_new> finder;
-                expr->accept( finder );
-                return finder.core.delExpr;
+                return ast::Pass<DeleteFinder_new>::read( expr );
         }
 
@@ -1171 +1170 @@
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
-                        return findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::start( untyped );
+                        auto res = findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::stop();
+                        return res;
                 }
         } // anonymous namespace
@@ -1261 +1263 @@
                 const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
                 const ast::CatchStmt *       previsit( const ast::CatchStmt * );
+                const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
                 const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
 
@@ -1493 +1496 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                // TODO: This will need a fix for the decl/cond scoping problem.
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // holds, check it. This allows a check for when to decode the mangling.
+                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
+                        assert( ifStmt->thenPart );
+                }
+                // Encode the catchStmt so the condition can see the declaration.
                 if ( catchStmt->cond ) {
-                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
-                        catchStmt = ast::mutate_field(
-                                catchStmt, &ast::CatchStmt::cond,
-                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
+                        ast::CatchStmt * stmt = mutate( catchStmt );
+                        stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
+                        stmt->cond = nullptr;
+                        return stmt;
+                }
+                return catchStmt;
+        }
+
+        const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->cond );
+                        assert( ifStmt->elsePart );
+                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
+                        stmt->cond = ifStmt->cond;
+                        stmt->body = ifStmt->elsePart;
+                        // ifStmt should be implicately deleted here.
+                        return stmt;
                 }
                 return catchStmt;