Merge #592

592: TypeCastExpr r=philberty a=philberty

This is the initial type casting rules more test cases will be added over time. To find gaps.

Fixes #158

Co-authored-by: Philip Herron <[email protected]>
Co-authored-by: Mark Wielaard <[email protected]>

Author: 3 people

gcc/rust/backend/rust-compile-expr.h

@@ -417,6 +417,24 @@ class CompileExpr : public HIRCompileBase
       = ctx->get_backend ()->negation_expression (op, negated_expr, location);
   }
 
+  void visit (HIR::TypeCastExpr &expr) override
+  {
+    TyTy::BaseType *tyty_to_cast_to = nullptr;
+    if (!ctx->get_tyctx ()->lookup_type (expr.get_mappings ().get_hirid (),
+					 &tyty_to_cast_to))
+      {
+	translated = ctx->get_backend ()->error_expression ();
+	return;
+      }
+
+    auto type_to_cast_to = TyTyResolveCompile::compile (ctx, tyty_to_cast_to);
+    auto casted_expr
+      = CompileExpr::Compile (expr.get_casted_expr ().get (), ctx);
+    translated
+      = ctx->get_backend ()->convert_expression (type_to_cast_to, casted_expr,
+						 expr.get_locus ());
+  }
+
   void visit (HIR::IfExpr &expr) override
   {
     auto stmt = CompileConditionalBlocks::compile (&expr, ctx, nullptr);

gcc/rust/hir/rust-ast-lower-base.h

@@ -295,6 +295,8 @@ class ASTLoweringBase : public AST::ASTVisitor
   HIR::GenericArgsBinding lower_binding (AST::GenericArgsBinding &binding);
 
   HIR::SelfParam lower_self (AST::SelfParam &self);
+
+  HIR::Type *lower_type_no_bounds (AST::TypeNoBounds *type);
 };
 
 } // namespace HIR

gcc/rust/hir/rust-ast-lower-expr.h

@@ -410,6 +410,25 @@ class ASTLoweringExpr : public ASTLoweringBase
 			       expr.get_locus ());
   }
 
+  void visit (AST::TypeCastExpr &expr) override
+  {
+    HIR::Expr *expr_to_cast_to
+      = ASTLoweringExpr::translate (expr.get_casted_expr ().get ());
+    HIR::Type *type_to_cast_to
+      = lower_type_no_bounds (expr.get_type_to_cast_to ().get ());
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   UNKNOWN_LOCAL_DEFID);
+
+    translated
+      = new HIR::TypeCastExpr (mapping,
+			       std::unique_ptr<HIR::Expr> (expr_to_cast_to),
+			       std::unique_ptr<HIR::Type> (type_to_cast_to),
+			       expr.get_locus ());
+  }
+
   /* Compound assignment expression is compiled away. */
   void visit (AST::CompoundAssignmentExpr &expr) override
   {

gcc/rust/hir/rust-ast-lower.cc

@@ -21,6 +21,7 @@
 #include "rust-ast-lower-implitem.h"
 #include "rust-ast-lower-expr.h"
 #include "rust-ast-lower-block.h"
+#include "rust-ast-lower-type.h"
 
 namespace Rust {
 namespace HIR {
@@ -394,5 +395,13 @@ ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment)
     segment.get_locus ());
 }
 
+// rust-ast-lower-base
+
+HIR::Type *
+ASTLoweringBase::lower_type_no_bounds (AST::TypeNoBounds *type)
+{
+  return ASTLoweringType::translate (type);
+}
+
 } // namespace HIR
 } // namespace Rust

gcc/rust/hir/tree/rust-hir-expr.h

@@ -538,7 +538,7 @@ class LazyBooleanExpr : public OperatorExpr
 // Binary infix "as" chir expression.
 class TypeCastExpr : public OperatorExpr
 {
-  std::unique_ptr<TypeNoBounds> type_to_convert_to;
+  std::unique_ptr<Type> type_to_convert_to;
 
   // Note: only certain type casts allowed, outlined in reference
 public:
@@ -547,7 +547,7 @@ class TypeCastExpr : public OperatorExpr
   // Constructor requires calling protected constructor of OperatorExpr
   TypeCastExpr (Analysis::NodeMapping mappings,
 		std::unique_ptr<Expr> expr_to_cast,
-		std::unique_ptr<TypeNoBounds> type_to_cast_to, Location locus)
+		std::unique_ptr<Type> type_to_cast_to, Location locus)
     : OperatorExpr (std::move (mappings), std::move (expr_to_cast),
 		    AST::AttrVec (), locus),
       type_to_convert_to (std::move (type_to_cast_to))
@@ -557,15 +557,15 @@ class TypeCastExpr : public OperatorExpr
   // Copy constructor also requires calling protected constructor
   TypeCastExpr (TypeCastExpr const &other)
     : OperatorExpr (other),
-      type_to_convert_to (other.type_to_convert_to->clone_type_no_bounds ())
+      type_to_convert_to (other.type_to_convert_to->clone_type ())
   {}
 
   // Overload assignment operator to deep copy
   TypeCastExpr &operator= (TypeCastExpr const &other)
   {
     OperatorExpr::operator= (other);
     // main_or_left_expr = other.main_or_left_expr->clone_expr();
-    type_to_convert_to = other.type_to_convert_to->clone_type_no_bounds ();
+    type_to_convert_to = other.type_to_convert_to->clone_type ();
 
     return *this;
   }
@@ -576,6 +576,18 @@ class TypeCastExpr : public OperatorExpr
 
   void accept_vis (HIRVisitor &vis) override;
 
+  std::unique_ptr<Expr> &get_casted_expr ()
+  {
+    rust_assert (main_or_left_expr != nullptr);
+    return main_or_left_expr;
+  }
+
+  std::unique_ptr<Type> &get_type_to_convert_to ()
+  {
+    rust_assert (type_to_convert_to != nullptr);
+    return type_to_convert_to;
+  }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */

gcc/rust/resolve/rust-ast-resolve-expr.h

@@ -174,6 +174,12 @@ class ResolveExpr : public ResolverBase
     ResolveExpr::go (expr.get_negated_expr ().get (), expr.get_node_id ());
   }
 
+  void visit (AST::TypeCastExpr &expr) override
+  {
+    ResolveType::go (expr.get_type_to_cast_to ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_casted_expr ().get (), expr.get_node_id ());
+  }
+
   void visit (AST::IfExpr &expr) override
   {
     ResolveExpr::go (expr.get_condition_expr ().get (), expr.get_node_id ());

gcc/rust/typecheck/rust-hir-type-check-expr.h

@@ -1147,6 +1147,16 @@ class TypeCheckExpr : public TypeCheckBase
       }
   }
 
+  void visit (HIR::TypeCastExpr &expr) override
+  {
+    TyTy::BaseType *expr_to_convert
+      = TypeCheckExpr::Resolve (expr.get_casted_expr ().get (), false);
+    TyTy::BaseType *tyty_to_convert_to
+      = TypeCheckType::Resolve (expr.get_type_to_convert_to ().get ());
+
+    infered = expr_to_convert->cast (tyty_to_convert_to);
+  }
+
 private:
   TypeCheckExpr (bool inside_loop)
     : TypeCheckBase (), infered (nullptr), infered_array_elems (nullptr),