---

yaml
---
r: 163499
b: refs/heads/snap-stage3
c: 3925b4d
h: refs/heads/master
i:
  163497: 17b662a
  163495: 7019b4c
v: v3

Author: bkoropoff

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 13e7f9c0a7ced7c20ea909e46bc6c520a9a2b260
+refs/heads/snap-stage3: 3925b4d5c94c10f6e3cff05afcb5866d62a7235c
 refs/heads/try: 20cbbffeefc1f35e2ea63afce7b42fbd79611d42
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/test/run-pass/type-id-higher-rank.rs

@@ -0,0 +1,85 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that type IDs correctly account for higher-rank lifetimes
+// Also acts as a regression test for an ICE (issue #19791)
+
+#![feature(unboxed_closures)]
+
+use std::intrinsics::TypeId;
+
+fn main() {
+    // Bare fns
+    {
+        let a = TypeId::of::<fn(&'static int, &'static int)>();
+        let b = TypeId::of::<for<'a> fn(&'static int, &'a int)>();
+        let c = TypeId::of::<for<'a, 'b> fn(&'a int, &'b int)>();
+        let d = TypeId::of::<for<'a, 'b> fn(&'b int, &'a int)>();
+        assert!(a != b);
+        assert!(a != c);
+        assert!(a != d);
+        assert!(b != c);
+        assert!(b != d);
+        assert_eq!(c, d);
+
+        // Make sure De Bruijn indices are handled correctly
+        let e = TypeId::of::<for<'a> fn(fn(&'a int) -> &'a int)>();
+        let f = TypeId::of::<fn(for<'a> fn(&'a int) -> &'a int)>();
+        assert!(e != f);
+    }
+    // Stack closures
+    {
+        let a = TypeId::of::<|&'static int, &'static int|>();
+        let b = TypeId::of::<for<'a> |&'static int, &'a int|>();
+        let c = TypeId::of::<for<'a, 'b> |&'a int, &'b int|>();
+        let d = TypeId::of::<for<'a, 'b> |&'b int, &'a int|>();
+        assert!(a != b);
+        assert!(a != c);
+        assert!(a != d);
+        assert!(b != c);
+        assert!(b != d);
+        assert_eq!(c, d);
+
+        // Make sure De Bruijn indices are handled correctly
+        let e = TypeId::of::<for<'a> |(|&'a int| -> &'a int)|>();
+        let f = TypeId::of::<|for<'a> |&'a int| -> &'a int|>();
+        assert!(e != f);
+    }
+    // Boxed unboxed closures
+    {
+        let a = TypeId::of::<Box<Fn(&'static int, &'static int)>>();
+        let b = TypeId::of::<Box<for<'a> Fn(&'static int, &'a int)>>();
+        let c = TypeId::of::<Box<for<'a, 'b> Fn(&'a int, &'b int)>>();
+        let d = TypeId::of::<Box<for<'a, 'b> Fn(&'b int, &'a int)>>();
+        assert!(a != b);
+        assert!(a != c);
+        assert!(a != d);
+        assert!(b != c);
+        assert!(b != d);
+        assert_eq!(c, d);
+
+        // Make sure De Bruijn indices are handled correctly
+        let e = TypeId::of::<Box<for<'a> Fn(Box<Fn(&'a int) -> &'a int>)>>();
+        let f = TypeId::of::<Box<Fn(Box<for<'a> Fn(&'a int) -> &'a int>)>>();
+        assert!(e != f);
+    }
+    // Raw unboxed closures
+    // Note that every unboxed closure has its own anonymous type,
+    // so no two IDs should equal each other, even when compatible
+    {
+        let a = id(|&: _: &int, _: &int| {});
+        let b = id(|&: _: &int, _: &int| {});
+        assert!(a != b);
+    }
+
+    fn id<T:'static>(_: T) -> TypeId {
+        TypeId::of::<T>()
+    }
+}