Changeset 25a1cb0 for src/ResolvExpr

Timestamp:

Sep 1, 2020, 1:18:10 PM (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

Children:

86c1f1c3, a77496cb

Parents:

8d8ac3b (diff), d3aa64f1 (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) (1 diff)
• Unify.cc (modified) (3 diffs)
• module.mk (modified) (2 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -1089 +1089 @@
                 }
 
+                void postvisit( const ast::KeywordCastExpr * castExpr ) {
+                        const auto & loc = castExpr->location;
+                        assertf( castExpr->result, "Cast target should have been set in Validate." );
+                        auto ref = castExpr->result.strict_as<ast::ReferenceType>();
+                        auto inst = ref->base.strict_as<ast::StructInstType>();
+                        auto target = inst->base.get();
+
+                        CandidateFinder finder{ symtab, tenv };
+
+                        auto pick_alternatives = [target, this](CandidateList & found, bool expect_ref) {
+                                for(auto & cand : found) {
+                                        const ast::Type * expr = cand->expr->result.get();
+                                        if(expect_ref) {
+                                                auto res = dynamic_cast<const ast::ReferenceType*>(expr);
+                                                if(!res) { continue; }
+                                                expr = res->base.get();
+                                        }
+
+                                        if(auto insttype = dynamic_cast<const ast::TypeInstType*>(expr)) {
+                                                auto td = cand->env.lookup(insttype->name);
+                                                if(!td) { continue; }
+                                                expr = td->bound.get();
+                                        }
+
+                                        if(auto base = dynamic_cast<const ast::StructInstType*>(expr)) {
+                                                if(base->base == target) {
+                                                        candidates.push_back( std::move(cand) );
+                                                        reason.code = NoReason;
+                                                }
+                                        }
+                                }
+                        };
+
+                        try {
+                                // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd
+                                // Clone is purely for memory management
+                                std::unique_ptr<const ast::Expr> tech1 { new ast::UntypedMemberExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.field), castExpr->arg) };
+
+                                // don't prune here, since it's guaranteed all alternatives will have the same type
+                                finder.find( tech1.get(), ResolvMode::withoutPrune() );
+                                pick_alternatives(finder.candidates, false);
+
+                                return;
+                        } catch(SemanticErrorException & ) {}
+
+                        // Fallback : turn (thread&)X into ($thread&)get_thread(X)
+                        std::unique_ptr<const ast::Expr> fallback { ast::UntypedExpr::createDeref(loc,  new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) };
+                        // don't prune here, since it's guaranteed all alternatives will have the same type
+                        finder.find( fallback.get(), ResolvMode::withoutPrune() );
+
+                        pick_alternatives(finder.candidates, true);
+
+                        // Whatever happens here, we have no more fallbacks
+                }
+
                 void postvisit( const ast::UntypedMemberExpr * memberExpr ) {
                         CandidateFinder aggFinder{ symtab, tenv };

src/ResolvExpr/Unify.cc

@@ -767 +767 @@
                 /// If this isn't done when satifying ttype assertions, then argument lists can have
                 /// different size and structure when they should be compatible.
-                struct TtypeExpander_new : public ast::WithShortCircuiting {
+                struct TtypeExpander_new : public ast::WithShortCircuiting, public ast::PureVisitor {
                         ast::TypeEnvironment & tenv;
 
@@ -793 +793 @@
                                 // TtypeExpander pass is impure (may mutate nodes in place)
                                 // need to make nodes shared to prevent accidental mutation
-                                ast::ptr<ast::DeclWithType> dc = d;
-                                dc = dc->accept( expander );
+                                ast::ptr<ast::DeclWithType> dc = d->accept(expander);
                                 auto types = flatten( dc->get_type() );
                                 for ( ast::ptr< ast::Type > & t : types ) {
@@ -1114 +1113 @@
                         ast::Pass<TtypeExpander_new> expander{ tenv };
 
-                        ast::ptr<ast::TupleType> tuplec = tuple;
-                        ast::ptr<ast::TupleType> tuple2c = tuple2;
-                        const ast::Type * flat = tuplec->accept( expander );
-                        const ast::Type * flat2 = tuple2c->accept( expander );
+                        // ast::ptr<ast::TupleType> tuplec = tuple;
+                        // ast::ptr<ast::TupleType> tuple2c = tuple2;
+                        const ast::Type * flat = tuple->accept( expander );
+                        const ast::Type * flat2 = tuple2->accept( expander );
 
                         auto types = flatten( flat );

src/ResolvExpr/module.mk

@@ -19 +19 @@
       ResolvExpr/Alternative.cc \
       ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/AlternativeFinder.h \
+      ResolvExpr/Alternative.h \
       ResolvExpr/Candidate.cpp \
       ResolvExpr/CandidateFinder.cpp \
+      ResolvExpr/CandidateFinder.hpp \
+      ResolvExpr/Candidate.hpp \
       ResolvExpr/CastCost.cc \
       ResolvExpr/CommonType.cc \
       ResolvExpr/ConversionCost.cc \
+      ResolvExpr/ConversionCost.h \
+      ResolvExpr/Cost.h \
       ResolvExpr/CurrentObject.cc \
+      ResolvExpr/CurrentObject.h \
       ResolvExpr/ExplodedActual.cc \
+      ResolvExpr/ExplodedActual.h \
       ResolvExpr/ExplodedArg.cpp \
+      ResolvExpr/ExplodedArg.hpp \
       ResolvExpr/FindOpenVars.cc \
+      ResolvExpr/FindOpenVars.h \
       ResolvExpr/Occurs.cc \
       ResolvExpr/PolyCost.cc \
@@ -33 +43 @@
       ResolvExpr/PtrsCastable.cc \
       ResolvExpr/RenameVars.cc \
+      ResolvExpr/RenameVars.h \
       ResolvExpr/ResolveAssertions.cc \
+      ResolvExpr/ResolveAssertions.h \
       ResolvExpr/Resolver.cc \
+      ResolvExpr/Resolver.h \
       ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/ResolveTypeof.h \
+      ResolvExpr/ResolvMode.h \
       ResolvExpr/SatisfyAssertions.cpp \
+      ResolvExpr/SatisfyAssertions.hpp \
       ResolvExpr/SpecCost.cc \
       ResolvExpr/TypeEnvironment.cc \
-      ResolvExpr/Unify.cc
+      ResolvExpr/TypeEnvironment.h \
+      ResolvExpr/typeops.h \
+      ResolvExpr/Unify.cc \
+      ResolvExpr/Unify.h \
+      ResolvExpr/WidenMode.h
 
-SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc
+
+SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc ResolvExpr/AlternativePrinter.h
 SRCDEMANGLE += $(SRC_RESOLVEXPR)