}
TyTy::BaseType *self = TypeCheckType::Resolve (impl_block.get_type ().get ());
+ if (self->is<TyTy::ErrorType> ())
+ {
+ // we cannot check for unconstrained type arguments when the Self type is
+ // not resolved it will just add extra errors that dont help as well as
+ // the case where this could just be a recursive type query that should
+ // fail and will work later on anyway
+ return {substitutions, region_constraints};
+ }
// inherit the bounds
if (!specified_bound.is_error ())
if (resolved == nullptr
|| resolved->get_kind () == TyTy::TypeKind::ERROR)
{
- rust_error_at (binding.get_locus (),
- "failed to resolve type arguments");
return SubstitutionArgumentMappings::error ();
}
BaseType *resolved = Resolver::TypeCheckType::Resolve (arg.get ());
if (resolved == nullptr || resolved->get_kind () == TyTy::TypeKind::ERROR)
{
- rust_error_at (args.get_locus (), "failed to resolve type arguments");
return SubstitutionArgumentMappings::error ();
}
--- /dev/null
+// { dg-options "-w" }
+#![feature(intrinsics)]
+#![feature(lang_items)]
+
+#[lang = "sized"]
+trait Sized {}
+
+extern "rust-intrinsic" {
+ fn transmute<T, U>(_: T) -> U;
+ fn offset<T>(src: *const T, offset: isize) -> *const T;
+}
+
+pub mod core {
+ pub mod marker {
+ #[lang = "phantom_data"]
+ pub struct PhantomData<T>;
+ }
+
+ pub mod slice {
+ use core::marker::PhantomData;
+ use core::option::Option;
+
+ impl<T> core::iter::IntoIterator for &[T] {
+ type Item = &T;
+ type IntoIter = Weird<T>;
+
+ fn into_iter(self) -> Weird<T> {
+ self.iter()
+ }
+ }
+
+ pub struct Weird<T> {
+ ptr: *const T, // should be NonNull<T> but here it does not matter
+ end: *const T,
+ _marker: PhantomData<&T>,
+ }
+
+ impl<T> Weird<T> {
+ pub(super) fn new(slice: &[T]) -> Self {
+ let ptr = slice.as_ptr();
+ // SAFETY: Similar to `IterMut::new`.
+ unsafe {
+ // should be: ptr.add(slice.len())
+ let end = transmute::<*const T, usize>(ptr) + slice.len(); // TODO(Arthur): Missing `* size_of::<T>()`?
+ let end = transmute::<usize, *const T>(end);
+
+ Self {
+ ptr,
+ end,
+ _marker: PhantomData,
+ }
+ }
+ }
+
+ fn is_empty(&self) -> bool {
+ self.ptr == self.end
+ }
+
+ fn next_unchecked(&mut self) -> *const T {
+ let old = self.ptr;
+
+ self.ptr = unsafe { offset(self.ptr, 1) };
+
+ old
+ }
+ }
+
+ trait Foo {}
+
+ impl<T> Foo for Weird<T> {}
+
+ // impl<T> core::iter::Iterator for Iter<T> {
+ // type Item = &T;
+
+ // fn next(&mut self) -> Option<&T> {
+ // if self.is_empty() {
+ // Option::None
+ // } else {
+ // Option::Some(&*self.next_unchecked())
+ // }
+ // }
+ // }
+
+ union Repr<T> {
+ pub(crate) rust: *const [T],
+ rust_mut: *mut [T],
+ pub(crate) raw: FatPtr<T>,
+ }
+
+ struct FatPtr<T> {
+ data: *const T,
+ pub(crate) len: usize,
+ }
+
+ impl<T> [T] {
+ pub fn iter(&self) -> Weird<T> {
+ Weird::new(self)
+ }
+
+ pub fn as_ptr(&self) -> *const T {
+ self as *const [T] as *const T
+ }
+
+ pub fn len(&self) -> usize {
+ unsafe { Repr { rust: self }.raw.len }
+ }
+ }
+ }
+
+ pub mod iter {
+ use option::Option;
+
+ pub trait IntoIterator {
+ type Item;
+
+ type IntoIter: Iterator<Item = Self::Item>;
+
+ fn into_iter(self) -> Self::IntoIter;
+ }
+
+ pub trait Iterator {
+ type Item;
+
+ fn next(&mut self) -> Option<Self::Item>;
+ }
+ }
+
+ pub mod option {
+ pub enum Option<T> {
+ Some(T),
+ None,
+ }
+ }
+}
+
+fn main() {}
projects / thirdparty / gcc.git / commitdiff
