Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Typedefs and static methods do not work together #3884

Closed
burg opened this issue Oct 29, 2012 · 1 comment
Closed

Typedefs and static methods do not work together #3884

burg opened this issue Oct 29, 2012 · 1 comment
Labels
A-resolve Area: Path resolution
Milestone

Comments

@burg
Copy link

burg commented Oct 29, 2012

It seems that a type definition will not introduce an implicit module for static methods defined in the thing being typedef'd. Consider the example below: one would expect Shaper::new() to resolve correctly.

Testcase:

mod foo {
    pub struct FooShaper {
        dummy: int
    }

    pub impl FooShaper {
        static pub fn new() -> FooShaper {
            FooShaper { dummy: 1337 }
        }
    }
}

fn main() {
    type Shaper/& = foo::FooShaper;

    let sh = Shaper::new();
    assert 1 + sh.dummy == 1338;
}

Compiler errors:

[burg@host-7-150 Desktop]# rustc test.rs
test.rs:16:13: 16:24 error: unresolved name
test.rs:16     let sh = Shaper::new();
                        ^~~~~~~~~~~
test.rs:16:13: 16:24 error: use of undeclared module `Shaper`
test.rs:16     let sh = Shaper::new();
                        ^~~~~~~~~~~
test.rs:16:13: 16:24 error: unresolved name: Shaper::new
test.rs:16     let sh = Shaper::new();
                        ^~~~~~~~~~~
error: aborting due to 3 previous errors
@brson
Copy link
Contributor

brson commented Oct 30, 2012

After discussion, this is probably intended behavior, for now at least. A workaround for most use cases is to write pub use foo = bar instead of pub type foo = bar.

@pcwalton pcwalton closed this as completed Dec 4, 2012
Jarcho pushed a commit to Jarcho/rust that referenced this issue Aug 31, 2022
Initial implementation `result_large_err`

This is a shot at rust-lang#6560, rust-lang#4652, and rust-lang#3884. The lint checks for `Result` being returned from functions/methods where the `Err` variant is larger than a configurable threshold (the default of which is 128 bytes). There has been some discussion around this, which I'll try to quickly summarize:

* A large `Err`-variant may force an equally large `Result` if `Err` is actually bigger than `Ok`.
* There is a cost involved in large `Result`, as LLVM may choose to `memcpy` them around above a certain size.
* We usually expect the `Err` variant to be seldomly used, but pay the cost every time.
* `Result` returned from library code has a high chance of bubbling up the call stack, getting stuffed into `MyLibError { IoError(std::io::Error), ParseError(parselib::Error), ...}`, exacerbating the problem.

This PR deliberately does not take into account comparing the `Ok` to the `Err` variant (e.g. a ratio, or one being larger than the other). Rather we choose an absolute threshold for `Err`'s size, above which we warn. The reason for this is that `Err`s probably get `map_err`'ed further up the call stack, and we can't draw conclusions from the ratio at the point where the `Result` is returned. A relative threshold would also be less predictable, while not accounting for the cost of LLVM being forced to generate less efficient code if the `Err`-variant is _large_ in absolute terms.

We lint private functions as well as public functions, as the perf-cost applies to in-crate code as well.

In order to account for type-parameters, I conjured up `fn approx_ty_size`. The function relies on `LateContext::layout_of` to compute the actual size, and in case of failure (e.g. due to generics) tries to come up with an "at least size". In the latter case, the size of obviously wrong, but the inspected size certainly can't be smaller than that. Please give the approach a heavy dose of review, as I'm not actually familiar with the type-system at all (read: I have no idea what I'm doing).

The approach does, however flimsy it is, allow us to successfully lint situations like

```rust
pub union UnionError<T: Copy> {
    _maybe: T,
    _or_perhaps_even: (T, [u8; 512]),
}

// We know `UnionError<T>` will be at least 512 bytes, no matter what `T` is
pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    Ok(())
}
```

I've given some refactoring to `functions/result_unit_err.rs` to re-use some bits. This is also the groundwork for rust-lang#6409

The default threshold is 128 because of rust-lang/rust-clippy#4652 (comment)

`lintcheck` does not trigger this lint for a threshold of 128. It does warn for 64, though.

The suggestion currently is the following, which is just a placeholder for discussion to be had. I did have the computed size in a `span_label`. However, that might cause both ui-tests here and lints elsewhere to become flaky wrt to their output (as the size is platform dependent).

```
error: the `Err`-variant returned via this `Result` is very large
  --> $DIR/result_large_err.rs:36:34
   |
LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeError)> {
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The `Err` variant is unusually large, at least 128 bytes
```

changelog: Add [`result_large_err`] lint
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
A-resolve Area: Path resolution
Projects
None yet
Development

No branches or pull requests

3 participants