Resolve and lower parenthesized types

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

@@ -19,6 +19,7 @@
 #include "rust-ast-lower-type.h"
 #include "rust-hir-map.h"
 #include "rust-hir-path.h"
+#include "rust-hir-type.h"
 #include "rust-path.h"
 #include "rust-pattern.h"
 
@@ -471,6 +472,24 @@ ASTLoweringType::visit (AST::TraitObjectType &type)
 					 type.get_locus (), type.is_dyn ());
 }
 
+void
+ASTLoweringType::visit (AST::ParenthesisedType &type)
+{
+  auto *inner = ASTLoweringType::translate (*type.get_type_in_parens (),
+					    default_to_static_lifetime);
+
+  auto crate_num = mappings.get_current_crate ();
+  Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
+				 mappings.get_next_hir_id (crate_num),
+				 mappings.get_next_localdef_id (crate_num));
+
+  // FIXME: Do we actually need to know if a type is parenthesized in the HIR?
+  // or can we just use the type in parens?
+  translated
+    = new HIR::ParenthesisedType (mapping, std::unique_ptr<HIR::Type> (inner),
+				  type.get_locus ());
+}
+
 HIR::GenericParam *
 ASTLowerGenericParam::translate (AST::GenericParam &param)
 {

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

@@ -22,6 +22,7 @@
 #include "rust-ast-lower-base.h"
 #include "rust-ast-lower-expr.h"
 #include "rust-hir-path.h"
+#include "rust-type.h"
 
 namespace Rust {
 namespace HIR {
@@ -83,6 +84,7 @@ class ASTLoweringType : public ASTLoweringBase
   void visit (AST::NeverType &type) override;
   void visit (AST::TraitObjectTypeOneBound &type) override;
   void visit (AST::TraitObjectType &type) override;
+  void visit (AST::ParenthesisedType &type) override;
 
 private:
   ASTLoweringType (bool default_to_static_lifetime)

gcc/rust/resolve/rust-ast-resolve-type.cc

@@ -48,6 +48,12 @@ ResolveType::visit (AST::TraitObjectType &type)
     }
 }
 
+void
+ResolveType::visit (AST::ParenthesisedType &type)
+{
+  resolved_node = ResolveType::go(*type.get_type_in_parens());
+}
+
 void
 ResolveType::visit (AST::ReferenceType &type)
 {

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

@@ -24,6 +24,7 @@
 #include "rust-diagnostics.h"
 #include "rust-hir-map.h"
 #include "rust-path.h"
+#include "rust-type.h"
 #include "util/rust-hir-map.h"
 
 namespace Rust {
@@ -143,6 +144,8 @@ class ResolveType : public ResolverBase
 
   void visit (AST::TraitObjectType &type) override;
 
+  void visit (AST::ParenthesisedType &type) override;
+
   void visit (AST::SliceType &type) override;
 
 private:

gcc/rust/typecheck/rust-hir-type-check-type.cc

@@ -785,6 +785,12 @@ TypeCheckType::visit (HIR::TraitObjectType &type)
 				   std::move (specified_bounds));
 }
 
+void
+TypeCheckType::visit (HIR::ParenthesisedType &type)
+{
+  translated = TypeCheckType::Resolve (type.get_type_in_parens ());
+}
+
 void
 TypeCheckType::visit (HIR::ArrayType &type)
 {

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

@@ -59,6 +59,7 @@ class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor
   void visit (HIR::InferredType &type) override;
   void visit (HIR::NeverType &type) override;
   void visit (HIR::TraitObjectType &type) override;
+  void visit (HIR::ParenthesisedType &type) override;
 
   void visit (HIR::TypePathSegmentFunction &segment) override
   { /* TODO */
@@ -69,9 +70,6 @@ class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor
   void visit (HIR::ImplTraitType &type) override
   { /* TODO */
   }
-  void visit (HIR::ParenthesisedType &type) override
-  { /* TODO */
-  }
   void visit (HIR::ImplTraitTypeOneBound &type) override
   { /* TODO */
   }

gcc/testsuite/rust/compile/auto_traits1.rs

@@ -0,0 +1,27 @@
+// { dg-additional-options "-frust-compile-until=typecheck" }
+
+#![feature(optin_builtin_traits)]
+
+pub unsafe auto trait Send {}
+#[lang = "sync"]
+pub unsafe auto trait Sync {}
+
+trait A {
+    fn a_method(&self) {}
+}
+
+fn foo(a: &(dyn A + Send + Sync)) {
+    a.a_method();
+}
+
+struct S;
+
+impl A for S {
+    fn a_method(&self) {}
+}
+
+fn main() {
+    let s = S;
+
+    foo(&s);
+}

gcc/testsuite/rust/compile/auto_traits2.rs

@@ -0,0 +1,26 @@
+#![feature(optin_builtin_traits)]
+
+pub unsafe auto trait Send {}
+#[lang = "sync"]
+pub unsafe auto trait Sync {}
+
+trait A {
+    fn a_method(&self) {}
+}
+
+fn foo(a: &(dyn A + Send + Sync)) { // { dg-error "bounds not satisfied" }
+                                    // { dg-error "mismatched type" "" { target *-*-* } .-1 }
+    a.a_method();
+}
+
+struct S;
+
+impl A for S {
+    fn a_method(&self) {}
+}
+
+fn main() {
+    let s = S;
+
+    foo(&s);
+}

gcc/testsuite/rust/compile/auto_traits3.rs

@@ -0,0 +1,34 @@
+#![feature(optin_builtin_traits)]
+
+pub unsafe auto trait Send {}
+#[lang = "sync"]
+pub unsafe auto trait Sync {}
+
+trait A {
+    fn a_method(&self) {}
+}
+
+fn foo(a: &(dyn A + Send + Sync)) {
+    a.a_method();
+}
+
+struct S;
+
+impl A for S {
+    fn a_method(&self) {} // { dg-warning "unused" }
+}
+
+// These should not be necessary because they are both auto traits
+// They need to be removed once we figure out the proper implementation for each of them
+// However, it'd be silly to implement other traits in order to ensure the test is okay,
+// as these extra trait bounds are only allowed to use auto traits
+// FIXME: #3327
+// FIXME: #3326
+unsafe impl Send for S {}
+unsafe impl Sync for S {}
+
+fn main() {
+    let s = S;
+
+    foo(&s);
+}