Ignore:
Timestamp:
Jun 13, 2019, 3:56:24 PM (3 years ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
6a1dfda
Parents:
d76f32c
Message:

Fixed convert-convert issues with strings, when conversion happens after resolve. Three specific issues fixed.

  1. String literals were not roundtripping new-old-new with the original type at the constant level, whereas the resolver changes the expression-level type from array to pointer.
  2. String literals were roundtripping with noise on a "--print astexpr" diff, with the char-array's index type coming up signed int (expecting unsigned long long int).
  3. Function calls that pass a foo[] variable as argument to a foo* formal were crashing on copy-constructor generation because convert-convert was changing the arg-expression type from foo* (set by the resolver, as expecteed) back to foo[], taken from the variable (switched to foo* taken from convert-src expression).
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    rd76f32c r6896548  
    733733        const ast::Expr * visit( const ast::VariableExpr * node ) override final {
    734734                auto expr = new VariableExpr();
     735                expr->var = get<DeclarationWithType>().accept1(node->var);
    735736                visitBaseExpr( node, expr );
    736                 expr->var = get<DeclarationWithType>().accept1(node->var);
    737                 Type * type = expr->var->get_type()->clone();
    738                 if(FunctionType * ft = dynamic_cast<FunctionType*>(type)) {
    739                         if(node->result.as<ast::PointerType>()) {
    740                                 type = new PointerType({}, ft);
    741                         }
    742                 }
    743 
    744                 type->set_lvalue( true );
    745                 expr->result = type ;
    746737                this->node = expr;
    747738                return nullptr;
     
    766757                        break;
    767758                case ast::ConstantExpr::String:
    768                         rslt = new ConstantExpr{Constant{
    769                                 get<Type>().accept1( node->result ),
    770                                 node->rep,
    771                                 (long long unsigned int)0
    772                         }};
     759                        // Old world:   two types: rslt->constant.type, rslt->result
     760                        // New workd:   one type: node->result
     761                        // Both worlds: the outer, expression-level type can change during resolution
     762                        //              in case of string, that's char[k] before-resolve and char * after
     763                        // Old world:   the inner Constant type stays what it was built with
     764                        //              in case of string, that's char[k]
     765                        // Both worlds: the "rep" field of a string constant is the string value it was initialized from, wrapped in quotes, but not otherwise escaped
     766                        ast::ptr<ast::Type> charType = nullptr;
     767                        if (const ast::ArrayType *arrRslt = node->result.as<ast::ArrayType>()) {
     768                                charType = arrRslt->base;
     769                        } else {
     770                                const ast::PointerType *ptrRslt = node->result.as<ast::PointerType>();
     771                                assert(ptrRslt);
     772                                charType = ptrRslt->base;
     773                        }
     774                        rslt = new ConstantExpr(Constant::from_string(
     775                                node->rep, get<Type>().accept1(charType)));          // rslt->result is char[k]
     776                        rslt->set_result( get<Type>().accept1( node->result ) ); // rslt->result is [[ node->rsult ]]
    773777                        break;
    774778                }
     
    21522156                );
    21532157
    2154                 visitBaseExpr_SkipResultType( old,
    2155                         expr
    2156                 );
    2157 
    21582158                expr->var = GET_ACCEPT_1(var, DeclWithType);
    2159                 expr->result = expr->var->get_type();
    2160                 if(const ast::FunctionType * ft = expr->result.as<ast::FunctionType>()) {
    2161                         if(dynamic_cast<PointerType *>(old->result)) {
    2162                                 expr->result = new ast::PointerType(ft);
    2163                         }
    2164                 }
    2165                 add_qualifiers( expr->result, ast::CV::Lvalue );
     2159                visitBaseExpr( old, expr );
     2160
    21662161                this->node = expr;
    21672162        }
     
    22142209                        rslt = new ast::ConstantExpr(
    22152210                                old->location,
    2216                                 GET_ACCEPT_1(result, Type),
     2211                                GET_ACCEPT_1(result, Type), // preserve the expression-level type (old->result, not old->constant.type); see new-to-old
    22172212                                old->constant.get_value(),
    22182213                                0,
Note: See TracChangeset for help on using the changeset viewer.