Changes in / [d945be9:7c80a86]

Location:

src

Files:

• AST/Expr.hpp (modified) (2 diffs)
• CodeGen/CodeGenerator.cpp (modified) (1 diff)
• GenPoly/Lvalue.cpp (modified) (4 diffs)
• Parser/ExpressionNode.cpp (modified) (1 diff)
• Parser/ExpressionNode.hpp (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (1 diff)

src/AST/Expr.hpp

@@ -330 +330 @@
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 
-/// Even within the basic cast expression there are variants:
-/// CCast - C-Style Cast: A backwards compatable cast from C.
-/// CoerceCast - Coercion Cast: Change the type without changing the value.
-/// ReturnCast - Ascription Cast: Requires the given expression result type.
-enum CastKind { CCast, CoerceCast, ReturnCast };
-
 /// A type cast, e.g. `(int)e`
 class CastExpr final : public Expr {
@@ -342 +336 @@
         GeneratedFlag isGenerated;
 
-        CastKind kind = CCast;
+        enum CastKind {
+                Default, // C
+                Coerce, // reinterpret cast
+                Return  // overload selection
+        };
+
+        CastKind kind = Default;
 
         CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
-                GeneratedFlag g = GeneratedCast, CastKind kind = CCast ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
+                GeneratedFlag g = GeneratedCast, CastKind kind = Default ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
         /// Cast-to-void
-        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = CCast );
+        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = Default );
 
         /// Wrap a cast expression around an existing expression (always generated)

src/CodeGen/CodeGenerator.cpp

@@ -680 +680 @@
         extension( expr );
         output << "(";
-        switch ( expr->kind ) {
-        case ast::CCast:
-                if ( expr->result->isVoid() ) {
-                        output << "(void)";
-                } else {
-                        output << "(";
-                        output << genType( expr->result, "", options );
-                        output << ")";
-                }
-                break;
-        case ast::CoerceCast:
-                assertf( ast::CoerceCast != expr->kind, "Coercion cast is not implemented." );
-                // And likely shouldn't reach code generation when it is implemented.
-                break;
-        case ast::ReturnCast:
-                // This should be invisible in the resulting C code.
-                // Can we insert a check here?
-                //assert( ResolvExpr::typesCompatable(???) );
-                if ( options.genC ) break;
-                output << "(return ";
+        if ( expr->result->isVoid() ) {
+                output << "(void)";
+        } else {
+                output << "(";
                 output << genType( expr->result, "", options );
                 output << ")";
-                break;
         }
         expr->arg->accept( *visitor );

src/GenPoly/Lvalue.cpp

@@ -315 +315 @@
                 SemanticWarning( expr->arg->location,
                         Warning::RvalueToReferenceConversion, toCString( expr->arg ) );
+
 
                 // allowing conversion in the rvalue to const ref case
@@ -365 +366 @@
                         ret = new ast::AddressExpr( ret->location, ret );
                 }
-                if ( !ResolvExpr::typesCompatible(
-                                srcType,
-                                strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
+                if ( expr->arg->get_lvalue() &&
+                                !ResolvExpr::typesCompatible(
+                                        srcType,
+                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
                         // Must keep cast if cast-to type is different from the actual type.
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
@@ -382 +384 @@
                 }
                 // Must keep cast if types are different.
-                if ( !ResolvExpr::typesCompatible(
+                if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
                                 dstType->stripReferences(),
                                 srcType->stripReferences() ) ) {
@@ -395 +397 @@
         } else {
                 assert( 0 == diff );
-                // Must keep cast if types are different. (Or it is explicit.)
-                if ( ast::ExplicitCast == expr->isGenerated ||
-                                !ResolvExpr::typesCompatible(
+                // Remove useless generated casts.
+                if ( expr->isGenerated == ast::GeneratedFlag::GeneratedCast &&
+                                ResolvExpr::typesCompatible(
                                         expr->result,
                                         expr->arg->result ) ) {
-                        return expr;
-                }
-                PRINT(
-                        std::cerr << "types are compatible, removing cast: " << expr << '\n';
-                        std::cerr << "-- " << expr->result << '\n';
-                        std::cerr << "-- " << expr->arg->result << std::endl;
-                )
-                return ast::mutate_field( expr->arg.get(),
-                                &ast::Expr::env, expr->env.get() );
+                        PRINT(
+                                std::cerr << "types are compatible, removing cast: " << expr << '\n';
+                                std::cerr << "-- " << expr->result << '\n';
+                                std::cerr << "-- " << expr->arg->result << std::endl;
+                        )
+                        auto argAsEnum = expr->arg.as<ast::EnumInstType>();
+                        auto resultAsEnum = expr->result.as<ast::EnumInstType>();
+                        if (argAsEnum && resultAsEnum) {
+                                if (argAsEnum->base->name != resultAsEnum->base->name) {
+                                        return expr;
+                                }
+                        }
+                        return ast::mutate_field( expr->arg.get(),
+                                        &ast::Expr::env, expr->env.get() );
+                }
+                return expr;
         }
 }

src/Parser/ExpressionNode.cpp

@@ -652 +652 @@
                 DeclarationNode * decl_node,
                 ExpressionNode * expr_node,
-                ast::CastKind kind ) {
+                ast::CastExpr::CastKind kind ) {
         ast::Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast<ast::VoidType *>( targetType ) ) {

src/Parser/ExpressionNode.hpp

@@ -69 +69 @@
 ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name );
 
-ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node, ast::CastKind kind = ast::CCast );
+ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node, ast::CastExpr::CastKind kind = ast::CastExpr::Default );
 ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node );
 ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );

src/Parser/parser.yy

@@ -979 +979 @@
                 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
-                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::ReturnCast ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }

src/ResolvExpr/CandidateFinder.cpp

@@ -1220 +1220 @@
                         finder.allowVoid = true;
                 }
-                if ( ast::ReturnCast == castExpr->kind ) {
+                if ( castExpr->kind == ast::CastExpr::Return ) {
                         finder.strictMode = true;
                         finder.find( castExpr->arg, ResolveMode::withAdjustment() );