Changeset 3b0c8cb

Timestamp:

Dec 5, 2019, 5:49:23 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

924c5ce

Parents:

1805b1b

Message:

Implemented Keyword cast in the alternative finder to remove aliassing problems

Location:

src

Files:

• Concurrency/Keywords.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• SynTree/Expression.h (modified) (1 diff)

src/Concurrency/Keywords.cc

@@ -309 +309 @@
                         if( !type_decl ) SemanticError( cast, context_error );
                         if( !dtor_decl ) SemanticError( cast, context_error );
-                        Expression * arg = cast->arg;
-                        cast->arg = nullptr;
-                        delete cast;
-                        return new CastExpr(
-                                UntypedExpr::createDeref(
-                                        new UntypedExpr( new NameExpr( getter_name ), { arg } )
-                                ),
-                                new ReferenceType(
-                                        noQualifiers,
-                                        new StructInstType( noQualifiers, type_decl ) )
-                                );
+                        assert( cast->result == nullptr );
+                        cast->set_result( new ReferenceType( noQualifiers, new StructInstType( noQualifiers, type_decl ) ) );
+                        cast->concrete_target.field  = field_name;
+                        cast->concrete_target.getter = getter_name;
                 }
                 return cast;

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_desc&)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_desc&)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/SynTree/Expression.h

@@ -231 +231 @@
         enum Target {
                 Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
-        } target;
+        };
+        struct Concrete {
+                std::string field;
+                std::string getter;
+        };
+        Target target;
+        Concrete concrete_target;
 
         KeywordCastExpr( Expression * arg, Target target );