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.

Sign up for GitHub

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

Jump to bottom

Generic alias doesn't respect type constraints #21181

Open
metagn opened this issue Dec 27, 2022 · 0 comments
Open

Generic alias doesn't respect type constraints #21181

metagn opened this issue Dec 27, 2022 · 0 comments
Labels
Generics Invalid Code Acceptance Everything related to compiler not complaining about invalid code

Comments

@metagn
Copy link
Collaborator

metagn commented Dec 27, 2022 •
edited
Loading

Description

type
  Foo[T: int] = T
  Bar[T] = Foo[T]
  
let x: Bar[string] = "abc"
echo x

Does not matter if Foo[T: int] = object or whatever

Nim Version

9b4516f

Current Output

abc

Expected Output

error T is not int

Possible Solution

No response

Additional Information

related #10739
@metagn metagn mentioned this issue Feb 22, 2023
Open
@metagn metagn mentioned this issue Jun 10, 2023
Open
@metagn metagn added the Invalid Code Acceptance Everything related to compiler not complaining about invalid code label Aug 28, 2023
@metagn metagn mentioned this issue Jul 20, 2024
Merged
Araq pushed a commit that referenced this issue Jul 20, 2024
@metagn
bypass constraints for tyFromExpr in generic bodies (#23863)
31ee75f 
fixes #19819, fixes #23339

Since #22029 `tyFromExpr` does not match anything in overloading, so
generic bodies can know which call expressions to delay until the type
can be evaluated. However generic type invocations also run overloading
to check for generic constraints even in generic bodies. To prevent them
from failing early from the overload not matching, pretend that
`tyFromExpr` matches. This mirrors the behavior of the compiler in more
basic cases like:

```nim
type
  Foo[T: int] = object
    x: T
  Bar[T] = object
    y: Foo[T]
```

Unfortunately this case doesn't respect the constraint (#21181, some
other bugs) but `tyFromExpr` should easily use the same principle when
it does.
narimiran pushed a commit that referenced this issue Dec 16, 2024
@metagn @narimiran
bypass constraints for tyFromExpr in generic bodies (#23863)
009a5b0 
fixes #19819, fixes #23339

Since #22029 `tyFromExpr` does not match anything in overloading, so
generic bodies can know which call expressions to delay until the type
can be evaluated. However generic type invocations also run overloading
to check for generic constraints even in generic bodies. To prevent them
from failing early from the overload not matching, pretend that
`tyFromExpr` matches. This mirrors the behavior of the compiler in more
basic cases like:

```nim
type
  Foo[T: int] = object
    x: T
  Bar[T] = object
    y: Foo[T]
```

Unfortunately this case doesn't respect the constraint (#21181, some
other bugs) but `tyFromExpr` should easily use the same principle when
it does.

(cherry picked from commit 31ee75f)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
Generics Invalid Code Acceptance Everything related to compiler not complaining about invalid code
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@bung87 @metagn