Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision d76f32c320117dca652f93256e6dcb16b3ed093c)
+++ src/AST/Convert.cpp	(revision 6a1dfdab0b3a899390e731091068f02d8d631676)
@@ -733,15 +733,6 @@
 	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,9 +757,22 @@
 			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,16 +2156,7 @@
 		);
 
-		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,5 +2209,5 @@
 			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,
Index: src/AST/Expr.cpp
===================================================================
--- src/AST/Expr.cpp	(revision d76f32c320117dca652f93256e6dcb16b3ed093c)
+++ src/AST/Expr.cpp	(revision 6a1dfdab0b3a899390e731091068f02d8d631676)
@@ -238,16 +238,4 @@
 }
 
-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{
Index: src/AST/Expr.hpp
===================================================================
--- src/AST/Expr.hpp	(revision d76f32c320117dca652f93256e6dcb16b3ed093c)
+++ src/AST/Expr.hpp	(revision 6a1dfdab0b3a899390e731091068f02d8d631676)
@@ -381,6 +381,4 @@
 	/// 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 );