Changes in src/AST/Convert.cpp [6896548:aaeacf4]

File:

• src/AST/Convert.cpp (modified) (6 diffs)

src/AST/Convert.cpp

@@ -733 +733 @@
         const ast::Expr * visit( const ast::VariableExpr * node ) override final {
                 auto expr = new VariableExpr();
+                visitBaseExpr( node, expr );
                 expr->var = get<DeclarationWithType>().accept1(node->var);
-                visitBaseExpr( node, expr );
+                Type * type = expr->var->get_type()->clone();
+                if(FunctionType * ft = dynamic_cast<FunctionType*>(type)) {
+                        if(node->result.as<ast::PointerType>()) {
+                                type = new PointerType({}, ft);
+                        }
+                }
+
+                type->set_lvalue( true );
+                expr->result = type ;
                 this->node = expr;
                 return nullptr;
@@ -757 +766 @@
                         break;
                 case ast::ConstantExpr::String:
-                        // Old world:   two types: rslt->constant.type, rslt->result
-                        // New workd:   one type: node->result
-                        // Both worlds: the outer, expression-level type can change during resolution
-                        //              in case of string, that's char[k] before-resolve and char * after
-                        // Old world:   the inner Constant type stays what it was built with
-                        //              in case of string, that's char[k]
-                        // Both worlds: the "rep" field of a string constant is the string value it was initialized from, wrapped in quotes, but not otherwise escaped
-                        ast::ptr<ast::Type> charType = nullptr;
-                        if (const ast::ArrayType *arrRslt = node->result.as<ast::ArrayType>()) {
-                                charType = arrRslt->base;
-                        } else {
-                                const ast::PointerType *ptrRslt = node->result.as<ast::PointerType>();
-                                assert(ptrRslt);
-                                charType = ptrRslt->base;
-                        }
-                        rslt = new ConstantExpr(Constant::from_string(
-                                node->rep, get<Type>().accept1(charType)));          // rslt->result is char[k]
-                        rslt->set_result( get<Type>().accept1( node->result ) ); // rslt->result is [[ node->rsult ]]
+                        rslt = new ConstantExpr{Constant{
+                                get<Type>().accept1( node->result ),
+                                node->rep,
+                                (long long unsigned int)0
+                        }};
                         break;
                 }
@@ -2156 +2152 @@
                 );
 
+                visitBaseExpr_SkipResultType( old,
+                        expr
+                );
+
                 expr->var = GET_ACCEPT_1(var, DeclWithType);
-                visitBaseExpr( old, expr );
-
+                expr->result = expr->var->get_type();
+                if(const ast::FunctionType * ft = expr->result.as<ast::FunctionType>()) {
+                        if(dynamic_cast<PointerType *>(old->result)) {
+                                expr->result = new ast::PointerType(ft);
+                        }
+                }
+                add_qualifiers( expr->result, ast::CV::Lvalue );
                 this->node = expr;
         }
@@ -2188 +2193 @@
 
         int isStringlikeConstantType(const Type *t) {
-                const Type *referentType = nullptr;
                 if ( const ArrayType * aty = dynamic_cast< const ArrayType * >( t ) ) {
-                        referentType = aty->base;
-                } else if ( const PointerType * pty = dynamic_cast< const PointerType * >( t ) ) {
-                        referentType = pty->base;
-                }
-                if (referentType) {
-                        if ( const BasicType * bty = dynamic_cast< const BasicType * >( referentType ) ) {
+                        if ( const BasicType * bty = dynamic_cast< const BasicType * >( aty->base ) ) {
                            if ( bty->kind == BasicType::Kind::Char ) {
                                    return true;
@@ -2206 +2205 @@
         virtual void visit( ConstantExpr * old ) override final {
                 ast::ConstantExpr *rslt = nullptr;
-                if (isStringlikeConstantType(old->result)) {
-                        rslt = new ast::ConstantExpr(
-                                old->location,
-                                GET_ACCEPT_1(result, Type), // preserve the expression-level type (old->result, not old->constant.type); see new-to-old
-                                old->constant.get_value(),
-                                0,
-                                ast::ConstantExpr::Kind::String
-                        );
-                } else if (isIntlikeConstantType(old->result)) {
+                if (isIntlikeConstantType(old->result)) {
                         rslt = new ast::ConstantExpr(
                                 old->location,
@@ -2228 +2219 @@
                                 old->constant.get_value(),
                                 (double) old->constant.get_dval()
+                        );
+                } else if (isStringlikeConstantType(old->result)) {
+                        rslt = new ast::ConstantExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                old->constant.get_value(),
+                                0,
+                                ast::ConstantExpr::Kind::String
                         );
                 }