Changeset d945be9

Timestamp:

Nov 20, 2024, 9:46:17 AM (3 hours ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Parents:

7c80a86 (diff), ecf3812 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

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 {
@@ -336 +342 @@
         GeneratedFlag isGenerated;
 
-        enum CastKind {
-                Default, // C
-                Coerce, // reinterpret cast
-                Return  // overload selection
-        };
-
-        CastKind kind = Default;
+        CastKind kind = CCast;
 
         CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
-                GeneratedFlag g = GeneratedCast, CastKind kind = Default ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
+                GeneratedFlag g = GeneratedCast, CastKind kind = CCast ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
         /// Cast-to-void
-        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = Default );
+        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = CCast );
 
         /// Wrap a cast expression around an existing expression (always generated)

src/CodeGen/CodeGenerator.cpp

@@ -680 +680 @@
         extension( expr );
         output << "(";
-        if ( expr->result->isVoid() ) {
-                output << "(void)";
-        } else {
-                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 ";
                 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
@@ -366 +365 @@
                         ret = new ast::AddressExpr( ret->location, ret );
                 }
-                if ( expr->arg->get_lvalue() &&
-                                !ResolvExpr::typesCompatible(
-                                        srcType,
-                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
+                if ( !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 );
@@ -384 +382 @@
                 }
                 // Must keep cast if types are different.
-                if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
+                if ( !ResolvExpr::typesCompatible(
                                 dstType->stripReferences(),
                                 srcType->stripReferences() ) ) {
@@ -397 +395 @@
         } else {
                 assert( 0 == diff );
-                // Remove useless generated casts.
-                if ( expr->isGenerated == ast::GeneratedFlag::GeneratedCast &&
-                                ResolvExpr::typesCompatible(
+                // Must keep cast if types are different. (Or it is explicit.)
+                if ( ast::ExplicitCast == expr->isGenerated ||
+                                !ResolvExpr::typesCompatible(
                                         expr->result,
                                         expr->arg->result ) ) {
-                        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;
+                        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() );
         }
 }

src/Parser/ExpressionNode.cpp

@@ -652 +652 @@
                 DeclarationNode * decl_node,
                 ExpressionNode * expr_node,
-                ast::CastExpr::CastKind kind ) {
+                ast::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::CastExpr::CastKind kind = ast::CastExpr::Default );
+ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node, ast::CastKind kind = ast::CCast );
 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::CastExpr::Return ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::ReturnCast ) ); }
         | '(' 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 ( castExpr->kind == ast::CastExpr::Return ) {
+                if ( ast::ReturnCast == castExpr->kind ) {
                         finder.strictMode = true;
                         finder.find( castExpr->arg, ResolveMode::withAdjustment() );