bug in method signatures with nested where inside variable bounds
#31542
Assignees
Labels
bug
Indicates an unexpected problem or unintended behavior
compiler:lowering
Syntax lowering (compiler front end, 2nd stage)
Comments
JeffBezanson
added
bug
vtjnash
added a commit
that referenced
this issue
Feb 9, 2025
Deferring this part of defining the ctor code allows it to do some
value-based optimizations, without the awkwardness previously of needing
to do conditional lowering of all of the possible versions that might be
useful just from syntax transforms. This feels very like a generated
function: how it expands just the function body, except it is flipped so
that then we wrap the result in a single Method instead of being created
from a Method!
Avoids lowering inaccuracies where a variable appears but is not used:
```julia
julia> struct Foo{T}
x::(T; Any)
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
julia> struct Foo{T}
x::Union{Any, T}
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
```
Avoids hitting #31542:
```julia
julia> struct Foo{T}
x::(Val{T} where T)
end
ERROR: syntax: invalid variable expression in "where" around REPL[1]:2
```
Avoids generating a `convert` call when the user declares explicit
`::Any` declarations, the same as if the user didn't annotate the field:
```julia
julia> struct Foo
x::Any
y::Int
end
julia> code_lowered(Foo)[2]
CodeInfo(
@ REPL[1]:2 within `unknown scope`
1 ─ %1 = builtin Core.fieldtype(#ctor-self#, 2)
│ %2 = y
│ @_4 = %2
│ %4 = builtin @_4 isa %1
└── goto #3 if not %4
2 ─ goto #4
3 ─ @_4 = Base.convert(%1, @_4)
4 ┄ %8 = @_4
│ %9 = %new(#ctor-self#, x, %8)
└── return %9
)
```
vtjnash
added a commit
that referenced
this issue
Feb 9, 2025
Deferring this part of defining the ctor code allows it to do some
value-based optimizations, without the awkwardness previously of needing
to do conditional lowering of all of the possible versions that might be
useful just from syntax transforms. This feels very like a generated
function: how it expands just the function body, except it is flipped so
that then we wrap the result in a single Method instead of being created
from a Method!
Avoids lowering inaccuracies where a variable appears but is not used.
These warnings are now prevented:
```julia
julia> struct Foo{T}
x::(T; Any)
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
julia> struct Foo{T}
x::Union{Any, T}
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
```
Avoids hitting #31542.
This lowering mistake is now avoided:
```julia
julia> struct Foo{T}
x::(Val{T} where T)
end
ERROR: syntax: invalid variable expression in "where" around REPL[1]:2
```
As a minor optimization, this avoids generating a `convert` call when
the user declares explicit `::Any` declarations, the same as if the user
didn't annotate the field type:
```julia
julia> struct Foo
x::Any
y::Int
z
end
julia> code_lowered(Foo)[2]
CodeInfo(
@ REPL[1]:2 within `unknown scope`
1 ─ %1 = builtin Core.fieldtype(#ctor-self#, 2)
│ %2 = y
│ @_4 = %2
│ %4 = builtin @_4 isa %1
└── goto #3 if not %4
2 ─ goto #4
3 ─ @_4 = Base.convert(%1, @_4)
4 ┄ %8 = @_4
│ %9 = %new(#ctor-self#, x, %8, z)
└── return %9
)
```
vtjnash
added a commit
that referenced
this issue
Feb 13, 2025
Deferring this part of defining the ctor code allows it to do some
value-based optimizations, without the awkwardness previously of needing
to do conditional lowering of all of the possible versions that might be
useful just from syntax transforms. This feels very like a generated
function: how it expands just the function body, except it is flipped so
that then we wrap the result in a single Method instead of being created
from a Method!
Avoids lowering inaccuracies where a variable appears but is not used.
These warnings are now prevented:
```julia
julia> struct Foo{T}
x::(T; Any)
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
julia> struct Foo{T}
x::Union{Any, T}
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
```
Avoids hitting #31542.
This lowering mistake is now avoided:
```julia
julia> struct Foo{T}
x::(Val{T} where T)
end
ERROR: syntax: invalid variable expression in "where" around REPL[1]:2
```
As a minor optimization, this avoids generating a `convert` call when
the user declares explicit `::Any` declarations, the same as if the user
didn't annotate the field type:
```julia
julia> struct Foo
x::Any
y::Int
z
end
julia> code_lowered(Foo)[2]
CodeInfo(
@ REPL[1]:2 within `unknown scope`
1 ─ %1 = builtin Core.fieldtype(#ctor-self#, 2)
│ %2 = y
│ @_4 = %2
│ %4 = builtin @_4 isa %1
└── goto #3 if not %4
2 ─ goto #4
3 ─ @_4 = Base.convert(%1, @_4)
4 ┄ %8 = @_4
│ %9 = %new(#ctor-self#, x, %8, z)
└── return %9
)
```
vtjnash
added a commit
that referenced
this issue
Feb 13, 2025
Deferring this part of defining the ctor code allows it to do some
value-based optimizations, without the awkwardness previously of needing
to do conditional lowering of all of the possible versions that might be
useful just from syntax transforms. This feels very like a generated
function: how it expands just the function body, except it is flipped so
that then we wrap the result in a single Method instead of being created
from a Method!
Avoids lowering inaccuracies where a variable appears but is not used.
These warnings are now prevented:
```julia
julia> struct Foo{T}
x::(T; Any)
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
julia> struct Foo{T}
x::Union{Any, T}
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
```
Avoids hitting #31542.
This lowering mistake is now avoided:
```julia
julia> struct Foo{T}
x::(Val{T} where T)
end
ERROR: syntax: invalid variable expression in "where" around REPL[1]:2
```
As a minor optimization, this avoids generating a `convert` call when
the user declares explicit `::Any` declarations, the same as if the user
didn't annotate the field type:
```julia
julia> struct Foo
x::Any
y::Int
z
end
julia> code_lowered(Foo)[2]
CodeInfo(
@ REPL[1]:2 within `unknown scope`
1 ─ %1 = builtin Core.fieldtype(#ctor-self#, 2)
│ %2 = y
│ @_4 = %2
│ %4 = builtin @_4 isa %1
└── goto #3 if not %4
2 ─ goto #4
3 ─ @_4 = Base.convert(%1, @_4)
4 ┄ %8 = @_4
│ %9 = %new(#ctor-self#, x, %8, z)
└── return %9
)
```
vtjnash
added a commit
that referenced
this issue
Feb 14, 2025
Deferring this part of defining the ctor code allows it to do some
value-based optimizations, without the awkwardness previously of needing
to do conditional lowering of all of the possible versions that might be
useful just from syntax transforms. This feels very like a generated
function: how it expands just the function body, except it is flipped so
that then we wrap the result in a single Method instead of being created
from a Method!
Avoids lowering inaccuracies where a variable appears but is not used.
These warnings are now prevented:
```julia
julia> struct Foo{T}
x::(T; Any)
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
julia> struct Foo{T}
x::Union{Any, T}
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
```
Avoids hitting #31542. This
lowering mistake is now avoided:
```julia
julia> struct Foo{T}
x::(Val{T} where T)
end
ERROR: syntax: invalid variable expression in "where" around REPL[1]:2
```
As a minor optimization, this avoids generating a `convert` call when
the user declares explicit `::Any` declarations, the same as if the user
didn't annotate the field type:
```julia
julia> struct Foo
x::Any
y::Int
z
end
julia> code_lowered(Foo)[2]
CodeInfo(
@ REPL[1]:2 within `unknown scope`
1 ─ %1 = builtin Core.fieldtype(#ctor-self#, 2)
│ %2 = y
│ @_4 = %2
│ %4 = builtin @_4 isa %1
└── goto #3 if not %4
2 ─ goto #4
3 ─ @_4 = Base.convert(%1, @_4)
4 ┄ %8 = @_4
│ %9 = %new(#ctor-self#, x, %8, z)
└── return %9
)
```
The outer/inner names might be a bit historical at this point (predating
where clauses allowing specifying them flexibly inside or outside of the
struct def): they are really exact-type-type&convert-args-from-any /
exact-arg-types&apply-type-from-args if named for precisely what they
do.
KristofferC
pushed a commit
that referenced
this issue
Feb 14, 2025
Deferring this part of defining the ctor code allows it to do some
value-based optimizations, without the awkwardness previously of needing
to do conditional lowering of all of the possible versions that might be
useful just from syntax transforms. This feels very like a generated
function: how it expands just the function body, except it is flipped so
that then we wrap the result in a single Method instead of being created
from a Method!
Avoids lowering inaccuracies where a variable appears but is not used.
These warnings are now prevented:
```julia
julia> struct Foo{T}
x::(T; Any)
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
julia> struct Foo{T}
x::Union{Any, T}
end
WARNING: method definition for Foo at REPL[1]:2 declares type variable T but does not use it.
```
Avoids hitting #31542. This
lowering mistake is now avoided:
```julia
julia> struct Foo{T}
x::(Val{T} where T)
end
ERROR: syntax: invalid variable expression in "where" around REPL[1]:2
```
As a minor optimization, this avoids generating a `convert` call when
the user declares explicit `::Any` declarations, the same as if the user
didn't annotate the field type:
```julia
julia> struct Foo
x::Any
y::Int
z
end
julia> code_lowered(Foo)[2]
CodeInfo(
@ REPL[1]:2 within `unknown scope`
1 ─ %1 = builtin Core.fieldtype(#ctor-self#, 2)
│ %2 = y
│ @_4 = %2
│ %4 = builtin @_4 isa %1
└── goto #3 if not %4
2 ─ goto #4
3 ─ @_4 = Base.convert(%1, @_4)
4 ┄ %8 = @_4
│ %9 = %new(#ctor-self#, x, %8, z)
└── return %9
)
```
The outer/inner names might be a bit historical at this point (predating
where clauses allowing specifying them flexibly inside or outside of the
struct def): they are really exact-type-type&convert-args-from-any /
exact-arg-types&apply-type-from-args if named for precisely what they
do.
(cherry picked from commit f4a9d25)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
This happens because of the odd way method signatures are lowered and the name collision with the inner and outer
A; it's not a problem forwhereexpressions generally:The text was updated successfully, but these errors were encountered: