Changeset 6896548 for src/AST/Convert.cpp

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:

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

src/AST/Convert.cpp

@@ -733 +733 @@
         const ast::Expr * visit( const ast::VariableExpr * node ) override final {
                 auto expr = new VariableExpr();
+                expr->var = get<DeclarationWithType>().accept1(node->var);
                 visitBaseExpr( node, expr );
-                expr->var = get<DeclarationWithType>().accept1(node->var);
-                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;
@@ -766 +757 @@
                         break;
                 case ast::ConstantExpr::String:
-                        rslt = new ConstantExpr{Constant{
-                                get<Type>().accept1( node->result ),
-                                node->rep,
-                                (long long unsigned int)0
-                        }};
+                        // 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 ]]
                         break;
                 }
@@ -2152 +2156 @@
                 );
 
-                visitBaseExpr_SkipResultType( old,
-                        expr
-                );
-
                 expr->var = GET_ACCEPT_1(var, DeclWithType);
-                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 );
+                visitBaseExpr( old, expr );
+
                 this->node = expr;
         }
@@ -2214 +2209 @@
                         rslt = new ast::ConstantExpr(
                                 old->location,
-                                GET_ACCEPT_1(result, Type),
+                                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,