Changes in src/AST/Convert.cpp [8b34df0:e6faef4]

File:

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

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Man Jun 10 11:51:00 2019
-// Update Count     : 11
+// Last Modified On : Mon Jun 17 16:44:00 2019
+// Update Count     : 12
 //
 
@@ -734 +734 @@
         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;
@@ -750 +741 @@
 
         const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
-                ConstantExpr *rslt = nullptr;
-                switch ( node->kind ) {
-                case ast::ConstantExpr::Integer:
-                        rslt = new ConstantExpr{Constant{
-                                get<Type>().accept1( node->result ),
-                                node->rep,
-                                (unsigned long long) node->intValue()
-                        }};
-                        break;
-                case ast::ConstantExpr::FloatingPoint:
-                        rslt = new ConstantExpr{Constant{
-                                get<Type>().accept1(node->result),
-                                node->rep,
-                                (double) node->floatValue()
-                        }};
-                        break;
-                case ast::ConstantExpr::String:
-                        rslt = new ConstantExpr{Constant{
-                                get<Type>().accept1( node->result ),
-                                node->rep,
-                                (long long unsigned int)0
-                        }};
-                        break;
-                }
-                assert(rslt);
+                // Old world:   two types: rslt->constant.type, rslt->result
+                // New workd:   one public type: node->result, plus node->underlyer only to support roundtrip conversion
+                //              preserving underlyer because the correct type for string literals is complicated to construct,
+            //              and distinguishing a string from other literals using the type is hard to do accurately
+                // Both worlds: the outer, expression-level type can change during resolution
+                //              for a string, that's char[k] before-resolve and char * after
+                // Old world:   the inner Constant type stays what it was built with
+                //              for a string, that's char[k] always
+                // Both worlds: the "rep" field of a constant is the C source file fragment that compiles to the desired value
+        //              for a string, that includes outer quotes, backslashes, et al cases from the Literals test
+                ConstantExpr *rslt = new ConstantExpr(Constant(
+                        get<Type>().accept1(node->underlyer),
+                        node->rep,
+                        node->ival));
                 auto expr = visitBaseExpr( node, rslt );
                 this->node = expr;
@@ -969 +949 @@
         const ast::Expr * visit( const ast::TupleExpr * node ) override final {
                 auto expr = visitBaseExpr( node,
-                        new UntypedTupleExpr(
+                        new TupleExpr(
                                 get<Expression>().acceptL(node->exprs)
                         )
@@ -1490 +1470 @@
                 decl->mangleName = old->mangleName;
                 decl->isDeleted  = old->isDeleted;
+                decl->asmName    = GET_ACCEPT_1(asmName, Expr);
                 decl->uniqueId   = old->uniqueId;
                 decl->extension  = old->extension;
@@ -1514 +1495 @@
                 decl->mangleName = old->mangleName;
                 decl->isDeleted  = old->isDeleted;
+                decl->asmName    = GET_ACCEPT_1(asmName, Expr);
                 decl->uniqueId   = old->uniqueId;
                 decl->extension  = old->extension;
@@ -2153 +2135 @@
                 );
 
-                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 );
-                this->node = expr;
-        }
-
-        bool isIntlikeConstantType(const Type *t) {
-                if ( const BasicType * basicType = dynamic_cast< const BasicType * >( t ) ) {
-                        if ( basicType->isInteger() ) {
-                                return true;
-                        }
-                } else if ( dynamic_cast< const OneType * >( t ) ) {
-                        return true;
-                } else if ( dynamic_cast< const ZeroType * >( t ) ) {
-                        return true;
-                } else if ( dynamic_cast< const PointerType * >( t ) ) {
-                        // null pointer constants, with zero int-values
-                        return true;
-                }
-                return false;
-        }
-
-        int isFloatlikeConstantType(const Type *t) {
-                if ( const BasicType * bty = dynamic_cast< const BasicType * >( t ) ) {
-                        if ( ! bty->isInteger() ) {
-                                return true;
-                        }
-                }
-                return false;
-        }
-
-        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 ( bty->kind == BasicType::Kind::Char ) {
-                                   return true;
-                           }
-                        }
-                }
-                return false;
+                visitBaseExpr( old, expr );
+
+                this->node = expr;
         }
 
         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),
-                                old->constant.get_value(),
-                                0,
-                                ast::ConstantExpr::Kind::String
-                        );
-                } else if (isIntlikeConstantType(old->result)) {
-                        rslt = new ast::ConstantExpr(
-                                old->location,
-                                GET_ACCEPT_1(result, Type),
-                                old->constant.get_value(),
-                                (unsigned long long) old->intValue(),
-                                ast::ConstantExpr::Kind::Integer
-                        );
-                } else if (isFloatlikeConstantType(old->result)) {
-                        rslt = new ast::ConstantExpr(
-                                old->location,
-                                GET_ACCEPT_1(result, Type),
-                                old->constant.get_value(),
-                                (double) old->constant.get_dval()
-                        );
-                }
-                assert(rslt);
+                ast::ConstantExpr *rslt = new ast::ConstantExpr(
+                        old->location,
+                        GET_ACCEPT_1(result, Type),
+                        old->constant.get_value(),
+                        old->constant.ival
+                );
+                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
                 this->node = visitBaseExpr( old, rslt );
         }