Annotate System.Linq.Expressions with RequiresDynamicCode

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616

[agocke]

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

[ghost]

Tagging subscribers to this area: @cston
See info in area-owners.md if you want to be subscribed.

Issue Details

---

All this ended up with an RDC on Expression.Compile due to new arrays. I could potentially silence this warning with a feature flag, but it is a real risk in AOT, and one that users could maybe work around if alerted to the problem.

Author:	agocke
Assignees:	agocke
Labels:	area-System.Linq.Expressions
Milestone:	-

[eerhardt]

This message is a bit weird (IMO). Anytime someone tries to compile an expression, they will get the warning

"Creating arrays at runtime requires dynamic code generation. This warning can be suppressed if there are no new array nodes in the expression tree."

But won't they already get the warning from the call that actually creates new array nodes in the expression tree? Therefore, we don't need to also warn them at Compile().

[agocke]

Hmm, hadn't thought of that. The problem is that something like Expression<Func<int[]>> e = () => new[] { 1 }; won't produce an analyzer warning since we don't see the call site, but maybe that can be OK for now and we can treat it as an analyzer improvement to fix later.

[eerhardt]

In that case, wouldn't it be fine? There's code there for a new int[].

[agocke]

Well, maybe. Replace int with your favorite custom struct. That likely wouldn't work.

[agocke]

@eerhardt Took your suggestion. There's now a suppression at the NewArrayExpression conversion routine.

[eerhardt]

@agocke - looks like this just missed the 8.0 cutoff. Do we want to backport this into .NET 8?

[agocke]

I think it would be a good idea, given that people are hitting this in the wild

[agocke]

/backport to release/8.0-rc1

[github-actions]

Started backporting to release/8.0-rc1: https://github.com/dotnet/runtime/actions/runs/5870002616