Fix bad name resolution of path with generic segments

When name-resolving paths we expect the name-resolver must resolve the
root of the path. Such that a path might be

  module::type::associated_function

We expect that the name resolution step must be able to resolve the

  module::type

Portion of the path, it is permissive to allow everything after that to
fail name resolution as this may require generic arguments of type
inferencing to figure out which associated items are required.

The issue in this referenced issue was that the generic arguments here were
wrongly canonicalized to be part of the root path which meant the segment
could not be name-resolved allowing the type resolution system to perform
the generic specialization.

Fixes #1173

Author: philberty

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

@@ -169,13 +169,8 @@ class ResolvePathSegmentToCanonicalPath
 	return CanonicalPath::create_empty ();
       }
 
-    std::string generics
-      = ResolveTypeToCanonicalPath::canonicalize_generic_args (
-	seg.get_generic_args ());
-
     return CanonicalPath::new_seg (seg.get_node_id (),
-				   seg.get_ident_segment ().as_string ()
-				     + "::" + generics);
+				   seg.get_ident_segment ().as_string ());
   }
 };
 

gcc/testsuite/rust/compile/issue-1173.rs

@@ -0,0 +1,20 @@
+// { dg-additional-options "-w" }
+mod mem {
+    extern "rust-intrinsic" {
+        fn transmute<U, V>(_: U) -> V;
+    }
+}
+
+pub trait Hasher {
+    fn write(&mut self, bytes: &[u8]);
+    fn write_u16(&mut self, i: u16) {
+        self.write(&mem::transmute::<_, [u8; 2]>(i))
+    }
+}
+
+pub struct SipHasher;
+
+impl Hasher for SipHasher {
+    #[inline]
+    fn write(&mut self, msg: &[u8]) {}
+}

gcc/testsuite/rust/compile/torture/issue-893-2.rs

@@ -24,7 +24,7 @@ impl Baz<i32, f32> {
 
 pub fn main() {
     let a = Foo::<i32>::new::<f32>(123, 456f32);
-    let b = Foo::new::<f32>(123, 456f32);
+    // let b = Foo::new::<f32>(123, 456f32);
 
     let c = Bar::<i32>(123);
     let d = Bar::baz(c);