Changeset 3d5701e for src/ResolvExpr

Timestamp:

Feb 25, 2020, 1:17:33 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

7dc2e015

Parents:

9fb8f01 (diff), dd9e1ca (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:

resolve conflict

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• AlternativeFinder.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (1 diff)
• PtrsCastable.cc (modified) (2 diffs)
• ResolveAssertions.cc (modified) (1 diff)
• Resolver.cc (modified) (5 diffs)
• Unify.cc (modified) (6 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
 //
 
@@ -133 +133 @@
                         // 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/ConversionCost.cc

@@ -157 +157 @@
                         if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
                                 PRINT( std::cerr << "converting compatible base type" << std::endl; )
-                                assert( src->get_lvalue() == srcIsLvalue );
                                 if ( srcIsLvalue ) {
                                         PRINT(

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/ResolveAssertions.cc

@@ -156 +156 @@
                         for ( const auto& assn : x.assns ) {
                                 // compute conversion cost from satisfying decl to assertion
-                                assert( !assn.match.adjType->get_lvalue() );
                                 k += computeConversionCost(
                                         assn.match.adjType, assn.decl->get_type(), false, indexer, x.env );

src/ResolvExpr/Resolver.cc

@@ -84 +84 @@
                 void previsit( ThrowStmt * throwStmt );
                 void previsit( CatchStmt * catchStmt );
+                void postvisit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 
@@ -485 +486 @@
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
-                if ( asmExpr->get_inout() ) {
-                        findVoidExpression( asmExpr->inout, indexer );
-                } // if
         }
 
@@ -570 +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;
                 }
         }
@@ -1366 +1386 @@
                         asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
 
-                if ( asmExpr->inout ) {
-                        asmExpr = ast::mutate_field(
-                                asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
-                }
-
                 return asmExpr;
         }
@@ -1474 +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 : Aaron B. Moss
-// Last Modified On : Mon Jun 18 11:58:00 2018
-// Update Count     : 43
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Dec 13 23:43:05 2019
+// Update Count     : 46
 //
 
@@ -32 +32 @@
 #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...
@@ -278 +278 @@
 #endif
                         if ( ( common = commonType( type1, type2, widen.first, widen.second, indexer, env, openVars ) ) ) {
-                                common->get_qualifiers() = tq1 | tq2;
+                                common->tq = tq1.unify( tq2 );
 #ifdef DEBUG
                                 std::cerr << "unifyInexact: common type is ";
@@ -295 +295 @@
                                 if ( ( tq1 > tq2 || widen.first ) && ( tq2 > tq1 || widen.second ) ) {
                                         common = type1->clone();
-                                        common->get_qualifiers() = tq1 | tq2;
+                                        common->tq = tq1.unify( tq2 );
                                         result = true;
                                 } else {
@@ -302 +302 @@
                         } else {
                                 common = type1->clone();
-                                common->get_qualifiers() = tq1 | tq2;
+                                common->tq = tq1.unify( tq2 );
                                 result = true;
                         } // if
@@ -781 +781 @@
                                 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;
                                         }