Changeset 7030dab for src/ResolvExpr

Timestamp:

Apr 6, 2020, 4:46:28 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

e3bc51c

Parents:

71d6bd8 (diff), 057298e (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' into new-ast

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• AlternativeFinder.cc (modified) (2 diffs)
• PtrsCastable.cc (modified) (2 diffs)
• Resolver.cc (modified) (6 diffs)
• Unify.cc (modified) (3 diffs)

src/ResolvExpr/AdjustExprType.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 23:41:42 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:34:53 2016
-// Update Count     : 4
+// Last Modified On : Wed Dec 11 21:43:56 2019
+// Update Count     : 6
 //
 
@@ -134 +134 @@
                         // replace known function-type-variables with pointer-to-function
                         if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {
-                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
+                                if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
                                         return new ast::PointerType{ inst };
                                 }
                         } else if ( const ast::NamedTypeDecl * ntDecl = symtab.lookupType( inst->name ) ) {
                                 if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( ntDecl ) ) {
-                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
+                                        if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
                                                 return new ast::PointerType{ inst };
                                         }

src/ResolvExpr/AlternativeFinder.cc

@@ -69 +69 @@
                 void postvisit( CastExpr * castExpr );
                 void postvisit( VirtualCastExpr * castExpr );
+                void postvisit( KeywordCastExpr * castExpr );
                 void postvisit( UntypedMemberExpr * memberExpr );
                 void postvisit( MemberExpr * memberExpr );
@@ -1255 +1256 @@
         }
 
+        void AlternativeFinder::Finder::postvisit( KeywordCastExpr * castExpr ) {
+                assertf( castExpr->get_result(), "Cast target should have been set in Validate." );
+                auto ref = dynamic_cast<ReferenceType*>(castExpr->get_result());
+                assert(ref);
+                auto inst = dynamic_cast<StructInstType*>(ref->base);
+                assert(inst);
+                auto target = inst->baseStruct;
+
+                AlternativeFinder finder( indexer, env );
+
+                auto pick_alternatives = [target, this](AltList & found, bool expect_ref) {
+                        for(auto & alt : found) {
+                                Type * expr = alt.expr->get_result();
+                                if(expect_ref) {
+                                        auto res = dynamic_cast<ReferenceType*>(expr);
+                                        if(!res) { continue; }
+                                        expr = res->base;
+                                }
+
+                                if(auto insttype = dynamic_cast<TypeInstType*>(expr)) {
+                                        auto td = alt.env.lookup(insttype->name);
+                                        if(!td) { continue; }
+                                        expr = td->type;
+                                }
+
+                                if(auto base = dynamic_cast<StructInstType*>(expr)) {
+                                        if(base->baseStruct == target) {
+                                                alternatives.push_back(
+                                                        std::move(alt)
+                                                );
+                                        }
+                                }
+                        }
+                };
+
+                try {
+                        // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd
+                        // Clone is purely for memory management
+                        std::unique_ptr<Expression> tech1 { new UntypedMemberExpr(new NameExpr(castExpr->concrete_target.field), castExpr->arg->clone()) };
+
+                        // don't prune here, since it's guaranteed all alternatives will have the same type
+                        finder.findWithoutPrune( tech1.get() );
+                        pick_alternatives(finder.alternatives, false);
+
+                        return;
+                } catch(SemanticErrorException & ) {}
+
+                // Fallback : turn (thread&)X into ($thread&)get_thread(X)
+                std::unique_ptr<Expression> fallback { UntypedExpr::createDeref( new UntypedExpr(new NameExpr(castExpr->concrete_target.getter), { castExpr->arg->clone() })) };
+                // don't prune here, since it's guaranteed all alternatives will have the same type
+                finder.findWithoutPrune( fallback.get() );
+
+                pick_alternatives(finder.alternatives, true);
+
+                // Whatever happens here, we have no more fallbacks
+        }
+
         namespace {
                 /// Gets name from untyped member expression (member must be NameExpr)

src/ResolvExpr/PtrsCastable.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 11:48:00 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:36:18 2016
-// Update Count     : 8
+// Last Modified On : Wed Dec 11 21:48:33 2019
+// Update Count     : 9
 //
 
@@ -176 +176 @@
                         if ( const ast::NamedTypeDecl * named = symtab.lookupType( inst->name ) ) {
                                 if ( auto tyDecl = dynamic_cast< const ast::TypeDecl * >( named ) ) {
-                                        if ( tyDecl->kind == ast::TypeVar::Ftype ) {
+                                        if ( tyDecl->kind == ast::TypeDecl::Ftype ) {
                                                 return -1;
                                         }
                                 }
                         } else if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
-                                if ( eqvClass->data.kind == ast::TypeVar::Ftype ) {
+                                if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
                                         return -1;
                                 }

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed May 29 11:00:00 2019
-// Update Count     : 241
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 27 11:58:00 2020
+// Update Count     : 242
 //
 
@@ -84 +84 @@
                 void previsit( ThrowStmt * throwStmt );
                 void previsit( CatchStmt * catchStmt );
+                void postvisit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 
@@ -559 +560 @@
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
-                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaehm_base_exception_t" );
                         assert( exception_decl );
                         Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
@@ -567 +568 @@
 
         void Resolver_old::previsit( CatchStmt * catchStmt ) {
+                // 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 ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
+                        assert( ifStmt->thenPart );
+                }
+                // Encode the catchStmt so the condition can see the declaration.
                 if ( catchStmt->cond ) {
-                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
+                        IfStmt * ifStmt = new IfStmt( catchStmt->cond, nullptr, catchStmt->body );
+                        catchStmt->cond = nullptr;
+                        catchStmt->body = ifStmt;
+                }
+        }
+
+        void Resolver_old::postvisit( CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->condition );
+                        assert( ifStmt->elsePart );
+                        catchStmt->cond = ifStmt->condition;
+                        catchStmt->body = ifStmt->elsePart;
+                        ifStmt->condition = nullptr;
+                        ifStmt->elsePart = nullptr;
+                        delete ifStmt;
                 }
         }
@@ -1454 +1477 @@
                 if ( throwStmt->expr ) {
                         const ast::StructDecl * exceptionDecl =
-                                symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                                symtab.lookupStruct( "__cfaehm_base_exception_t" );
                         assert( exceptionDecl );
                         ast::ptr< ast::Type > exceptType =
@@ -1466 +1489 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
+                // TODO: This will need a fix for the decl/cond scoping problem.
                 if ( catchStmt->cond ) {
                         ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };

src/ResolvExpr/Unify.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:27:10 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Sep  4 10:00:00 2019
-// Update Count     : 44
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Dec 13 23:43:05 2019
+// Update Count     : 46
 //
 
@@ -34 +34 @@
 #include "Common/PassVisitor.h"     // for PassVisitor
 #include "FindOpenVars.h"           // for findOpenVars
-#include "Parser/LinkageSpec.h"     // for C
+#include "SynTree/LinkageSpec.h"    // for C
 #include "SynTree/Constant.h"       // for Constant
 #include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
@@ -771 +771 @@
                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
                                         // expand ttype parameter into its actual type
-                                        if ( clz->data.kind == ast::TypeVar::Ttype && clz->bound ) {
+                                        if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
                                                 return clz->bound;
                                         }