Changes in / [06088f9a:fb57626]

Location:

src

Files:

• CodeTools/TrackLoc.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)
• ResolvExpr/CommonType.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (4 diffs)
• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (2 diffs)
• Tuples/TupleAssignment.cc (modified) (2 diffs)
• Tuples/TupleExpansion.cc (modified) (1 diff)

src/CodeTools/TrackLoc.cc

@@ -64 +64 @@
                                 }
                                 else {
-                                        assertf( false, "Top level node has no CodeLocation %s", name.c_str() );
+                                        assertf( false, "Top level node has no CodeLocation %s", toString( node ).c_str() );
                                 }
                         }

src/InitTweak/FixInit.cc

@@ -382 +382 @@
                         } // if
                         delete stmt;
+                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
+                                // fix newly generated StmtExpr
+                                postvisit( assign->stmtExpr );
+                        }
                         return resolved;
                 }
@@ -479 +483 @@
                                 env->apply( result );
                                 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
-                                ret->get_type()->set_const( false );
-                                stmtExpr->get_returnDecls().push_front( ret );
+                                ret->type->set_const( false );
+                                stmtExpr->returnDecls.push_front( ret );
 
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
+                                CompoundStmt * body = stmtExpr->statements;
                                 assert( ! body->get_kids().empty() );
                                 // must be an ExprStmt, otherwise it wouldn't have a result
                                 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
-                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
-
-                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
+                                last->expr = makeCtorDtor( "?{}", ret, last->get_expr() );
+
+                                stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
                 }
@@ -606 +610 @@
                                 // must have a non-empty body, otherwise it wouldn't have a result
                                 assert( ! stmts.empty() );
-                                assert( ! stmtExpr->get_returnDecls().empty() );
+                                assertf( ! stmtExpr->get_returnDecls().empty(), "StmtExpr returns non-void, but no return decls: %s", toString( stmtExpr ).c_str() );
                                 stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();

src/Parser/DeclarationNode.cc

@@ -343 +343 @@
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
+        if ( kind == OperKinds::And ) {
+                // T && is parsed as 'And' operator rather than two references => add a second reference type
+                TypeData * td = new TypeData( TypeData::Reference );
+                td->base = newnode->type;
+                newnode->type = td;
+        }
         if ( qualifiers ) {
                 return newnode->addQualifiers( qualifiers );

src/ResolvExpr/CommonType.cc

@@ -91 +91 @@
                         // special case where one type has a reference depth of 1 larger than the other
                         if ( diff > 0 || diff < 0 ) {
+                                // std::cerr << "reference depth diff: " << diff << std::endl;
                                 Type * result = nullptr;
-                                if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) {
+                                ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
+                                ReferenceType * ref2 = dynamic_cast< ReferenceType * >( type2 );
+                                if ( diff > 0 ) {
+                                        // deeper on the left
+                                        assert( ref1 );
+                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
+                                } else {
+                                        // deeper on the right
+                                        assert( ref2 );
+                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                }
+                                if ( result && ref1 ) {
                                         // formal is reference, so result should be reference
-                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
-                                        if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result );
-                                } else {
-                                        // formal is value, so result should be value
-                                        ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 );
-                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                        // std::cerr << "formal is reference; result should be reference" << std::endl;
+                                        result = new ReferenceType( ref1->get_qualifiers(), result );
                                 }
                                 // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;

src/ResolvExpr/ConversionCost.cc

@@ -92 +92 @@
 
         Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
-                PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )
+                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
                 if ( diff > 0 ) {
                         // TODO: document this
@@ -108 +108 @@
                         if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
                                 PRINT( std::cerr << "converting between references" << std::endl; )
-                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
-                                        return Cost::safe;
+                                Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
+                                Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
+                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
+                                        if ( tq1 == tq2 ) {
+                                                // types are the same
+                                                return Cost::zero;
+                                        } else {
+                                                // types are the same, except otherPointer has more qualifiers
+                                                return Cost::safe;
+                                        }
                                 } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
                                         int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
@@ -271 +280 @@
         void ConversionCost::visit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
+                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
                         Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
                         Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
                         if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                 if ( tq1 == tq2 ) {
                                         // types are the same
@@ -280 +290 @@
                                 } else {
                                         // types are the same, except otherPointer has more qualifiers
-                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                         cost = Cost::safe;
                                 }
-                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                        } else {
                                 int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
                                 PRINT( std::cerr << " :: " << assignResult << std::endl; )
-                                if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
-                                        cost = Cost::safe;
+                                if ( assignResult > 0 && tq1 <= tq2 ) {
+                                        // xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct?
+                                        if ( tq1 == tq2 ) {
+                                                cost = Cost::safe;
+                                        } else if ( tq1 < tq2 ) {
+                                                cost = Cost::safe+Cost::safe;
+                                        }
                                 } else if ( assignResult < 0 ) {
                                         cost = Cost::unsafe;

src/SymTab/Indexer.cc

@@ -572 +572 @@
         }
 
+        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr ) {
+                for ( Declaration * decl : aggr->members ) {
+                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                addId( dwt, expr );
+                                if ( dwt->name == "" ) {
+                                        Type * t = dwt->get_type()->stripReferences();
+                                        if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
+                                                Expression * base = expr->clone();
+                                                ResolvExpr::referenceToRvalueConversion( base );
+                                                addMembers( t->getAggr(), new MemberExpr( dwt, base ) );
+                                        }
+                                }
+                        }
+                }
+        }
+
         void Indexer::addWith( WithStmt * stmt ) {
                 for ( Expression * expr : stmt->exprs ) {
@@ -578 +594 @@
                                 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
 
-                                for ( Declaration * decl : aggr->members ) {
-                                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
-                                                addId( dwt, expr );
-                                        }
-                                }
+                                addMembers( aggr, expr );
                         }
                 }

src/SymTab/Indexer.h

@@ -86 +86 @@
                 void addWith( WithStmt * );
 
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( AggregateDecl * aggr, Expression * expr );
+
                 /// convenience function for adding a list of Ids to the indexer
                 void addIds( const std::list< DeclarationWithType * > & decls );

src/SymTab/Validate.cc

@@ -94 +94 @@
                 template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
 
-                bool inStruct = false;
+                AggregateDecl * parentAggr = nullptr;
         };
 
@@ -303 +303 @@
         template< typename AggDecl >
         void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
-                if ( inStruct ) {
+                if ( parentAggr ) {
                         // Add elements in stack order corresponding to nesting structure.
                         declsToAddBefore.push_front( aggregateDecl );
                 } else {
-                        GuardValue( inStruct );
-                        inStruct = true;
+                        GuardValue( parentAggr );
+                        parentAggr = aggregateDecl;
                 } // if
                 // Always remove the hoisted aggregate from the inner structure.

src/Tuples/TupleAssignment.cc

@@ -272 +272 @@
                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
                 if ( right ) args.push_back( new VariableExpr( right ) );
-                return new UntypedExpr( new NameExpr( fname ), args );
+                if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
+                        args.front() = new AddressExpr( args.front() );
+                        if ( right ) args.back() = new AddressExpr( args.back() );
+                        return new UntypedExpr( new NameExpr( "?=?" ), args );
+                } else {
+                        return new UntypedExpr( new NameExpr( fname ), args );
+                }
         }
 
@@ -291 +297 @@
                 if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
                         ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
-                        ret->set_init( ctorInit );
+                        ret->init = ctorInit;
                         ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
                         PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs

src/Tuples/TupleExpansion.cc

@@ -202 +202 @@
                         // generate struct type to replace tuple type based on the number of components in the tuple
                         StructDecl * decl = new StructDecl( toString( "_tuple", tupleSize, "_" ) );
+                        decl->location = tupleType->location;
                         decl->set_body( true );
                         for ( size_t i = 0; i < tupleSize; ++i ) {