Changes in / [dc5072f:6a1dfda]

Files:

• src/AST/Convert.cpp (modified) (4 diffs)
• src/AST/Expr.cpp (modified) (3 diffs)
• src/AST/Expr.hpp (modified) (2 diffs)
• src/Parser/ExpressionNode.cc (modified) (1 diff)
• src/ResolvExpr/Candidate.hpp (modified) (2 diffs)
• src/SynTree/Constant.cc (modified) (1 diff)
• src/SynTree/Constant.h (modified) (1 diff)
• tests/.in/manipulatorsInput.txt (modified) (1 diff)

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,

src/AST/Expr.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May 15 17:00:00 2019
-// Last Modified By : Aaron B. Moss
-// Created On       : Wed May 15 17:00:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Created On       : Thr Jun 13 13:38:00 2019
+// Update Count     : 2
 //
 
@@ -238 +238 @@
 }
 
-ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & s ) {
-        return new ConstantExpr{
-                loc,
-                new ArrayType{
-                        new BasicType{ BasicType::Char, CV::Const },
-                        ConstantExpr::from_int( loc, s.size() + 1 /* null terminator */ ),
-                        FixedLen, DynamicDim },
-                std::string{"\""} + s + "\"",
-                (unsigned long long)0,
-                ConstantExpr::String };
-}
-
 ConstantExpr * ConstantExpr::null( const CodeLocation & loc, const Type * ptrType ) {
         return new ConstantExpr{
@@ -382 +370 @@
 
 UniqueExpr::UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i )
-: Expr( loc, e->result ), id( i ) {
+: Expr( loc, e->result ), expr( e ), id( i ) {
         assert( expr );
         if ( id == -1ull ) {

src/AST/Expr.hpp

@@ -381 +381 @@
         /// generates a floating point constant of the given double
         static ConstantExpr * from_double( const CodeLocation & loc, double d );
-        /// generates an array of chars constant of the given string
-        static ConstantExpr * from_string( const CodeLocation & loc, const std::string & s );
         /// generates a null pointer value for the given type. void * if omitted.
         static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
@@ -693 +691 @@
         unsigned long long id;
 
-        UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1 );
+        UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1ull );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/Parser/ExpressionNode.cc

@@ -354 +354 @@
                 strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
         } // switch
-        ArrayType * at = new ArrayType( noQualifiers, strtype,
-                                                                        new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
-                                                                        false, false );
-        Expression * ret = new ConstantExpr( Constant( at, str, (unsigned long long int)0 ) ); // constant 0 is ignored for pure string value
+        Expression * ret = new ConstantExpr( Constant::from_string( str, strtype ) );
         if ( units.length() != 0 ) {
                 ret = new UntypedExpr( new NameExpr( units ), { ret } );

src/ResolvExpr/Candidate.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed Jun 5 14:30:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 12 14:15:00 2019
+// Update Count     : 2
 //
 
@@ -49 +49 @@
 
         Candidate() : expr(), cost( Cost::zero ), cvtCost( Cost::zero ), env(), open(), need() {}
-        
+
         Candidate( const ast::Expr * x, const ast::TypeEnvironment & e )
         : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() {}
 
         Candidate( const Candidate & o, const ast::Expr * x )
-        : expr( x ), cost( o.cost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ), 
+        : expr( x ), cost( o.cost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ),
           need( o.need ) {}
-        
-        Candidate( 
-                const ast::Expr * x, ast::TypeEnvironment && e, ast::OpenVarSet && o, 
-                ast::AssertionSet && n, const Cost & c )
-        : expr( x ), cost( c ), cvtCost( Cost::zero ), env( std::move( e ) ), open( std::move( o ) ), 
+
+        Candidate(
+                const ast::Expr * x, ast::TypeEnvironment && e, ast::OpenVarSet && o,
+                ast::AssertionSet && n, const Cost & c, const Cost & cvt = Cost::zero )
+        : expr( x ), cost( c ), cvtCost( cvt ), env( std::move( e ) ), open( std::move( o ) ),
           need( n.begin(), n.end() ) {}
 };

src/SynTree/Constant.cc

@@ -51 +51 @@
 }
 
-Constant Constant::from_string( std::string const & str ) {
-        return Constant(
-                new ArrayType(
-                        noQualifiers,
-                        new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
-                        new ConstantExpr( Constant::from_int( str.size() + 1 /* \0 */ )),
-                        false, false ),
-                std::string("\"") + str + "\"", (unsigned long long int)0 );
+Constant Constant::from_string( std::string const & cEscapedVal, Type *charType ) {
+        assert(cEscapedVal.length() >= 2);
+        assert(cEscapedVal.front() == '"');
+        assert(cEscapedVal.back() == '"');
+        ArrayType * at = new ArrayType( noQualifiers, charType,
+                                                                        new ConstantExpr( Constant::from_ulong( cEscapedVal.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
+                                                                        false, false );
+        return Constant( at, cEscapedVal, (unsigned long long int)0 );
 }
 

src/SynTree/Constant.h

@@ -52 +52 @@
         static Constant from_double( double d );
         /// generates an array of chars constant of the given string
-        static Constant from_string( std::string const & s );
+        static Constant from_string( std::string const & cEscapedVal, Type *charType  );
 
         /// generates a null pointer value for the given type. void * if omitted.

tests/.in/manipulatorsInput.txt

@@ -5 +5 @@
 abcyyy
 aaaaaaaaxxxxxxxxaabbccbbdddwwwbbbbbbbbwwwwwwwwaaaaaaaawwwwwwww
-abc 
 abc 
 xx