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

Reflection patterns can not resolve assemblies outside of the reference closure #943

Closed
sbomer opened this issue Feb 10, 2020 · 2 comments
Closed

Reflection patterns can not resolve assemblies outside of the reference closure #943

sbomer opened this issue Feb 10, 2020 · 2 comments
Labels
area-Linker: Steps
Milestone
6.0.x

Comments

@sbomer
Copy link
Member

sbomer commented Feb 10, 2020

When a supported reflection pattern references an assembly that is part of the linker input set, but not in the reference closure of any roots (and thus not loaded into the LinkContext assemblies by LoadReferencesStep or any other step that comes before MarkStep), the pattern will fail to resolve. Since simple reflection patterns are often used for activation without a build-time dependency, this seems like something worth supporting. See dotnet/sdk#4017 for the original issue with a repro.

#843 is a similar issue where PreserveDependency doesn't cause xml roots from the referenced assembly to be processed.

If we fix this, we should be able to undo dotnet/runtime#32023.
@vitek-karas vitek-karas mentioned this issue Feb 19, 2020
Merged
@vitek-karas vitek-karas mentioned this issue Apr 20, 2020
Closed
10 tasks
@MichalStrehovsky MichalStrehovsky mentioned this issue Apr 20, 2020
Open
12 tasks
@marek-safar marek-safar mentioned this issue May 4, 2020
Closed
@MichalStrehovsky MichalStrehovsky mentioned this issue Jun 4, 2020
Merged
@MichalStrehovsky MichalStrehovsky mentioned this issue Jun 12, 2020
Merged
@MichalStrehovsky MichalStrehovsky mentioned this issue Jun 25, 2020
Merged
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable recursive processing of dynamic assemblies
46d672f 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and constant propagation will also happen for lazy assemblies

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
2bac4f4 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and constant propagation will also happen for lazy assemblies

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
e5e714b 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
30a0d7d 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
a82027b 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
67a083b 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
3909867 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Nov 4, 2020
@sbomer
Enable processing of dynamically referenced assemblies
ae7e85f 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
@sbomer sbomer mentioned this issue Nov 6, 2020
Closed
@marek-safar marek-safar added this to the .NET 6.0 milestone Nov 13, 2020
sbomer added a commit to sbomer/linker that referenced this issue Dec 2, 2020
@sbomer
Enable processing of dynamically referenced assemblies
25bf381 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Dec 3, 2020
@sbomer
Enable processing of dynamically referenced assemblies
3a1f314 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Dec 7, 2020
@sbomer
Enable processing of dynamically referenced assemblies
3baf402 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Dec 9, 2020
@sbomer
Enable processing of dynamically referenced assemblies
fc6ae7c 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Dec 10, 2020
@sbomer
Enable processing of dynamically referenced assemblies
6606168 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Dec 14, 2020
@sbomer
Enable processing of dynamically referenced assemblies
a5532da 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Jan 4, 2021
@sbomer
Enable processing of dynamically referenced assemblies
274572c 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Jan 15, 2021
@sbomer
Enable processing of dynamically referenced assemblies
cca77ef 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
sbomer added a commit to sbomer/linker that referenced this issue Jan 20, 2021
@sbomer
Enable processing of dynamically referenced assemblies
312fad9 
This introduces the ability to add assemblies to LinkContext lazily and have them
processed in MarkStep. For now, the only additional processing is to
load references and run the TypeMap logic. Later, embedded XML processing and
constant propagation will also happen for lazy assemblies.

This is Phase 1 outlined in dotnet#1164 (comment).

Fixes dotnet#943
Fixes dotnet#1079
@marek-safar
Copy link
Contributor

I believe this should be fixed. @sbomer could you please undo the runtime change so we can fully verify this and close ?

@sbomer
Copy link
Member Author

sbomer commented Mar 12, 2021

Fixed by #1666, runtime workarounds removed in dotnet/runtime#49523.

@sbomer sbomer closed this as completed Mar 12, 2021
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
area-Linker: Steps
Projects
None yet
Milestone
6.0.x
Development

Successfully merging a pull request may close this issue.

Enable processing of dynamically referenced assemblies sbomer/linker
2 participants
@marek-safar @sbomer