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

File:

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

src/AST/Convert.cpp

@@ -576 +576 @@
                 if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
                         const ast::InferredParams &srcParams = srcInferred.inferParams();
-                        for (auto srcParam : srcParams) {
-                                tgtInferParams[srcParam.first] = ParamEntry(
+                        for (auto & srcParam : srcParams) {
+                                auto res = tgtInferParams.emplace(srcParam.first, ParamEntry(
                                         srcParam.second.decl,
                                         get<Declaration>().accept1(srcParam.second.declptr),
@@ -583 +583 @@
                                         get<Type>().accept1(srcParam.second.formalType),
                                         get<Expression>().accept1(srcParam.second.expr)
-                                );
+                                ));
+                                assert(res.second);
                         }
                 } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
@@ -733 +734 @@
         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;
@@ -740 +750 @@
 
         const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
-                // 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));
+                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);
                 auto expr = visitBaseExpr( node, rslt );
                 this->node = expr;
@@ -1982 +2003 @@
                 if ( !oldInferParams.empty() ) {
                         ast::InferredParams &tgt = newInferred.inferParams();
-                        for (auto old : oldInferParams) {
+                        for (auto & old : oldInferParams) {
                                 tgt[old.first] = ast::ParamEntry(
                                         old.second.decl,
@@ -2132 +2153 @@
                 );
 
+                visitBaseExpr_SkipResultType( old,
+                        expr
+                );
+
                 expr->var = GET_ACCEPT_1(var, DeclWithType);
-                visitBaseExpr( old, expr );
-
-                this->node = 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;
+        }
+
+        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;
         }
 
         virtual void visit( ConstantExpr * old ) override final {
-                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() );
+                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);
                 this->node = visitBaseExpr( old, rslt );
         }