From 46d672f39468f07da21a324a155c86972db6ee3e Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Wed, 4 Nov 2020 00:03:06 +0000 Subject: [PATCH] Enable recursive processing of dynamic assemblies 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 https://github.com/mono/linker/issues/943 Fixes https://github.com/mono/linker/issues/1079 --- .../ReflectionMethodBodyScanner.cs | 5 +++- .../DynamicDependencyLookupStep.cs | 8 ++---- src/linker/Linker.Steps/IAssemblyStep.cs | 15 ++++++++++ src/linker/Linker.Steps/LinkAttributesStep.cs | 7 +++-- src/linker/Linker.Steps/LoadReferencesStep.cs | 28 +++++++++++++++++-- src/linker/Linker.Steps/MarkStep.cs | 23 ++++++++++++--- .../Linker.Steps/ProcessLinkerXmlStepBase.cs | 2 +- .../Linker.Steps/ResolveFromAssemblyStep.cs | 1 + src/linker/Linker.Steps/ResolveFromXmlStep.cs | 3 +- src/linker/Linker.Steps/TypeMapStep.cs | 17 ++++++++--- src/linker/Linker/Driver.cs | 12 +++++--- src/linker/Linker/LinkContext.cs | 9 ++++++ src/linker/Linker/Pipeline.cs | 15 ++++++++++ .../CoreLibraryAssemblyAttributesAreKept.cs | 3 ++ .../CopyOfCoreLibrariesKeepsUnusedTypes.cs | 3 ++ ...odInNonReferencedAssemblyChainedLibrary.cs | 2 +- ...DependencyMethodInNonReferencedAssembly.cs | 1 - ...ncyMethodInNonReferencedAssemblyChained.cs | 4 +-- ...InNonReferencedAssemblyChainedReference.cs | 4 +-- ...odInNonReferencedAssemblyChainedLibrary.cs | 2 +- .../PreserveDependencyErrorCases.cs | 3 +- ...ncyMethodInNonReferencedAssemblyChained.cs | 3 +- ...InNonReferencedAssemblyChainedReference.cs | 3 +- .../AssemblyImportedViaReflection.cs | 1 - ...blyImportedViaReflectionWithDerivedType.cs | 1 - ...emblyImportedViaReflectionWithReference.cs | 1 - 26 files changed, 131 insertions(+), 45 deletions(-) create mode 100644 src/linker/Linker.Steps/IAssemblyStep.cs diff --git a/src/linker/Linker.Dataflow/ReflectionMethodBodyScanner.cs b/src/linker/Linker.Dataflow/ReflectionMethodBodyScanner.cs index e21f0c7a85d3..fa30d0dce436 100644 --- a/src/linker/Linker.Dataflow/ReflectionMethodBodyScanner.cs +++ b/src/linker/Linker.Dataflow/ReflectionMethodBodyScanner.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. @@ -807,6 +807,7 @@ public override bool HandleCall (MethodBody callingMethodBody, MethodReference c // Intentionally ignore - it's not wrong for code to call Type.GetType on non-existing name, the code might expect null/exception back. reflectionContext.RecordHandledPattern (); } else { + _context.ProcessReferenceClosure (foundType.Module.Assembly); reflectionContext.RecordRecognizedPattern (foundType, () => _markStep.MarkTypeVisibleToReflection (foundTypeRef, new DependencyInfo (DependencyKind.AccessedViaReflection, callingMethodDefinition), callingMethodDefinition)); methodReturnValue = MergePointValue.MergeValues (methodReturnValue, new SystemTypeValue (foundType)); } @@ -1339,6 +1340,7 @@ void ProcessCreateInstanceByName (ref ReflectionPatternContext reflectionContext reflectionContext.RecordUnrecognizedPattern (2061, $"The assembly name '{assemblyNameStringValue.Contents}' passed to method '{calledMethod.GetDisplayName ()}' references assembly which is not available."); continue; } + _context.ProcessReferenceClosure (resolvedAssembly); var typeRef = _context.TypeNameResolver.ResolveTypeName (resolvedAssembly, typeNameStringValue.Contents); var resolvedType = typeRef?.Resolve (); @@ -1579,6 +1581,7 @@ void RequireDynamicallyAccessedMembers (ref ReflectionPatternContext reflectionC // Intentionally ignore - it's not wrong for code to call Type.GetType on non-existing name, the code might expect null/exception back. reflectionContext.RecordHandledPattern (); } else { + _context.ProcessReferenceClosure (foundType.Module.Assembly); MarkType (ref reflectionContext, typeRef); MarkTypeForDynamicallyAccessedMembers (ref reflectionContext, foundType, requiredMemberTypes); } diff --git a/src/linker/Linker.Steps/DynamicDependencyLookupStep.cs b/src/linker/Linker.Steps/DynamicDependencyLookupStep.cs index 61d07237390b..cea8dcc4567d 100644 --- a/src/linker/Linker.Steps/DynamicDependencyLookupStep.cs +++ b/src/linker/Linker.Steps/DynamicDependencyLookupStep.cs @@ -4,14 +4,13 @@ using System; using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; using Mono.Cecil; #nullable enable namespace Mono.Linker.Steps { - public class DynamicDependencyLookupStep : LoadReferencesStep + public class DynamicDependencyLookupStep : BaseStep { protected override void ProcessAssembly (AssemblyDefinition assembly) { @@ -74,7 +73,7 @@ void ProcessDynamicDependencyAttributes (IMemberDefinition member) var assembly = Context.Resolve (new AssemblyNameReference (assemblyName, new Version ())); if (assembly == null) continue; - ProcessReferences (assembly); + Context.ProcessReferenceClosure (assembly); } } @@ -90,8 +89,7 @@ void ProcessDynamicDependencyAttributes (IMemberDefinition member) Context.LogWarning ($"Unresolved assembly '{dynamicDependency.AssemblyName}' in 'DynamicDependencyAttribute'", 2035, member); continue; } - - ProcessReferences (assembly); + Context.ProcessReferenceClosure (assembly); } } diff --git a/src/linker/Linker.Steps/IAssemblyStep.cs b/src/linker/Linker.Steps/IAssemblyStep.cs new file mode 100644 index 000000000000..e4757169e576 --- /dev/null +++ b/src/linker/Linker.Steps/IAssemblyStep.cs @@ -0,0 +1,15 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Mono.Cecil; +using System.Collections.Generic; + +namespace Mono.Linker.Steps +{ + public interface IAssemblyStep + { + void Initialize (LinkContext context); + void ProcessAssemblies (HashSet assembly); + } +} \ No newline at end of file diff --git a/src/linker/Linker.Steps/LinkAttributesStep.cs b/src/linker/Linker.Steps/LinkAttributesStep.cs index e0be36e38bec..2187f535a0ac 100644 --- a/src/linker/Linker.Steps/LinkAttributesStep.cs +++ b/src/linker/Linker.Steps/LinkAttributesStep.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. @@ -173,6 +173,8 @@ bool GetAttributeType (XPathNodeIterator iterator, string attributeFullName, out } attributeType = Context.TypeNameResolver.ResolveTypeName (assembly, attributeFullName)?.Resolve (); + if (attributeType != null) + Context.ProcessReferenceClosure (attributeType.Module.Assembly); } if (attributeType == null) { @@ -341,8 +343,7 @@ protected override AssemblyDefinition GetAssembly (LinkContext context, Assembly { var assembly = context.Resolve (assemblyName); if (assembly != null) - ProcessReferences (assembly); - + context.ProcessReferenceClosure (assembly); return assembly; } } diff --git a/src/linker/Linker.Steps/LoadReferencesStep.cs b/src/linker/Linker.Steps/LoadReferencesStep.cs index 59928adcb3f0..a972168cd460 100644 --- a/src/linker/Linker.Steps/LoadReferencesStep.cs +++ b/src/linker/Linker.Steps/LoadReferencesStep.cs @@ -32,13 +32,33 @@ namespace Mono.Linker.Steps { - public class LoadReferencesStep : BaseStep + public class LoadReferencesStep : IAssemblyStep { + LinkContext _context; + + LinkContext Context => _context; + readonly HashSet references = new HashSet (); - protected override void ProcessAssembly (AssemblyDefinition assembly) + HashSet newReferences = new HashSet (); + + public void Initialize (LinkContext context) { - ProcessReferences (assembly); + _context = context; + } + + public virtual void ProcessAssemblies (HashSet assemblies) + { + newReferences.Clear (); + + foreach (var assembly in assemblies) + ProcessReferences (assembly); + + // Ensure that subsequent IAssemblySteps only process assemblies + // which have not already been processed. + assemblies.Clear (); + foreach (var assembly in newReferences) + assemblies.Add (assembly); } protected void ProcessReferences (AssemblyDefinition assembly) @@ -46,6 +66,8 @@ protected void ProcessReferences (AssemblyDefinition assembly) if (!references.Add (assembly.Name)) return; + newReferences.Add (assembly); + Context.RegisterAssembly (assembly); foreach (AssemblyDefinition referenceDefinition in Context.ResolveReferences (assembly)) { diff --git a/src/linker/Linker.Steps/MarkStep.cs b/src/linker/Linker.Steps/MarkStep.cs index 0a27d919b96b..9fdf44c79577 100644 --- a/src/linker/Linker.Steps/MarkStep.cs +++ b/src/linker/Linker.Steps/MarkStep.cs @@ -347,6 +347,9 @@ void Process () if (!assembly.MainModule.HasExportedTypes) continue; + // We may have resolved new type forwarder assemblies which have not been processed. + _context.ProcessReferenceClosure (assembly); + foreach (var exported in assembly.MainModule.ExportedTypes) { bool isForwarder = exported.IsForwarder; var declaringType = exported.DeclaringType; @@ -633,11 +636,12 @@ void MarkDynamicDependency (DynamicDependency dynamicDependency, IMemberDefiniti Debug.Assert (context is MethodDefinition || context is FieldDefinition); AssemblyDefinition assembly; if (dynamicDependency.AssemblyName != null) { - assembly = _context.GetLoadedAssembly (dynamicDependency.AssemblyName); + assembly = _context.Resolve (dynamicDependency.AssemblyName); if (assembly == null) { _context.LogWarning ($"Unresolved assembly '{dynamicDependency.AssemblyName}' in 'DynamicDependencyAttribute'", 2035, context); return; } + _context.ProcessReferenceClosure (assembly); } else { assembly = context.DeclaringType.Module.Assembly; Debug.Assert (assembly != null); @@ -741,12 +745,13 @@ protected virtual void MarkUserDependency (MemberReference context, CustomAttrib AssemblyDefinition assembly; var args = ca.ConstructorArguments; if (args.Count >= 3 && args[2].Value is string assemblyName) { - assembly = _context.GetLoadedAssembly (assemblyName); + assembly = _context.Resolve (assemblyName); if (assembly == null) { _context.LogWarning ( $"Could not resolve dependency assembly '{assemblyName}' specified in a 'PreserveDependency' attribute", 2003, context.Resolve ()); return; } + _context.ProcessReferenceClosure (assembly); } else { assembly = null; } @@ -1567,12 +1572,19 @@ TypeDefinition GetDebuggerAttributeTargetType (CustomAttribute ca, AssemblyDefin if (property.Name == "TargetTypeName") { string targetTypeName = (string) property.Argument.Value; TypeName typeName = TypeParser.ParseTypeName (targetTypeName); + TypeDefinition typeDef = null; if (typeName is AssemblyQualifiedTypeName assemblyQualifiedTypeName) { AssemblyDefinition assembly = _context.GetLoadedAssembly (assemblyQualifiedTypeName.AssemblyName.Name); - return _context.TypeNameResolver.ResolveTypeName (assembly, targetTypeName)?.Resolve (); + typeDef = _context.TypeNameResolver.ResolveTypeName (assembly, targetTypeName)?.Resolve (); + if (typeDef != null) + _context.ProcessReferenceClosure (typeDef.Module.Assembly); + return typeDef; } - return _context.TypeNameResolver.ResolveTypeName (asm, targetTypeName)?.Resolve (); + typeDef = _context.TypeNameResolver.ResolveTypeName (asm, targetTypeName)?.Resolve (); + if (typeDef != null) + _context.ProcessReferenceClosure (typeDef.Module.Assembly); + return typeDef; } } @@ -1666,6 +1678,9 @@ protected virtual void MarkTypeConverterLikeDependency (CustomAttribute attribut switch (attribute.ConstructorArguments[0].Value) { case string s: tdef = _context.TypeNameResolver.ResolveTypeName (s)?.Resolve (); + if (tdef != null) + _context.ProcessReferenceClosure (tdef.Module.Assembly); + // ResolveTypeName might resolve an assembly (or multiple assemblies for generic arguments...) break; case TypeReference type: tdef = type.Resolve (); diff --git a/src/linker/Linker.Steps/ProcessLinkerXmlStepBase.cs b/src/linker/Linker.Steps/ProcessLinkerXmlStepBase.cs index 264bd821b2f7..f955fabc489a 100644 --- a/src/linker/Linker.Steps/ProcessLinkerXmlStepBase.cs +++ b/src/linker/Linker.Steps/ProcessLinkerXmlStepBase.cs @@ -7,7 +7,7 @@ namespace Mono.Linker.Steps { - public abstract class ProcessLinkerXmlStepBase : LoadReferencesStep + public abstract class ProcessLinkerXmlStepBase : BaseStep { const string FullNameAttributeName = "fullname"; const string LinkerElementName = "linker"; diff --git a/src/linker/Linker.Steps/ResolveFromAssemblyStep.cs b/src/linker/Linker.Steps/ResolveFromAssemblyStep.cs index a3bc7e897b02..3138eecd618e 100644 --- a/src/linker/Linker.Steps/ResolveFromAssemblyStep.cs +++ b/src/linker/Linker.Steps/ResolveFromAssemblyStep.cs @@ -67,6 +67,7 @@ protected override void Process () Context.Resolver.IgnoreUnresolved = false; AssemblyDefinition assembly = _assembly ?? Context.Resolve (_file); Context.Resolver.IgnoreUnresolved = ignoreUnresolved; + Context.ProcessReferenceClosure (assembly); if (_rootVisibility != RootVisibility.Any && HasInternalsVisibleTo (assembly)) _rootVisibility = RootVisibility.PublicAndFamilyAndAssembly; diff --git a/src/linker/Linker.Steps/ResolveFromXmlStep.cs b/src/linker/Linker.Steps/ResolveFromXmlStep.cs index f7cd9a5e59ff..f476313d5676 100644 --- a/src/linker/Linker.Steps/ResolveFromXmlStep.cs +++ b/src/linker/Linker.Steps/ResolveFromXmlStep.cs @@ -320,8 +320,7 @@ protected override AssemblyDefinition GetAssembly (LinkContext context, Assembly { var assembly = context.Resolve (assemblyName); if (assembly != null) - ProcessReferences (assembly); - + context.ProcessReferenceClosure (assembly); return assembly; } diff --git a/src/linker/Linker.Steps/TypeMapStep.cs b/src/linker/Linker.Steps/TypeMapStep.cs index de4f323a6ed7..336f107ce0e8 100644 --- a/src/linker/Linker.Steps/TypeMapStep.cs +++ b/src/linker/Linker.Steps/TypeMapStep.cs @@ -32,13 +32,22 @@ namespace Mono.Linker.Steps { - public class TypeMapStep : BaseStep + public class TypeMapStep : IAssemblyStep { + LinkContext _context; + AnnotationStore Annotations => _context.Annotations; - protected override void ProcessAssembly (AssemblyDefinition assembly) + public void Initialize (LinkContext context) { - foreach (TypeDefinition type in assembly.MainModule.Types) - MapType (type); + _context = context; + } + + public void ProcessAssemblies (HashSet assemblies) + { + foreach (var assembly in assemblies) { + foreach (TypeDefinition type in assembly.MainModule.Types) + MapType (type); + } } protected virtual void MapType (TypeDefinition type) diff --git a/src/linker/Linker/Driver.cs b/src/linker/Linker/Driver.cs index 0d590e460099..98a558e02383 100644 --- a/src/linker/Linker/Driver.cs +++ b/src/linker/Linker/Driver.cs @@ -701,7 +701,6 @@ protected int SetupContext (ILogger customLogger = null) // ResolveFromAssemblyStep [optional, possibly many] // ResolveFromXmlStep [optional, possibly many] // [mono only] ResolveFromXApiStep [optional, possibly many] - // LoadReferencesStep // [mono only] LoadI18nAssemblies // BlacklistStep // dynamically adds steps: @@ -711,7 +710,6 @@ protected int SetupContext (ILogger customLogger = null) // LinkAttributesStep [optional, possibly many] // DynamicDependencyLookupStep // [mono only] PreserveCalendarsStep [optional] - // TypeMapStep // BodySubstituterStep [optional] // RemoveSecurityStep [optional] // [mono only] RemoveFeaturesStep [optional] @@ -726,6 +724,12 @@ protected int SetupContext (ILogger customLogger = null) // RegenerateGuidStep [optional] // SealerStep // OutputStep + + // + // Pipeline Steps which run when new assemblies are processed + // + // LoadReferencesStep + // TypeMapStep // foreach (string custom_step in custom_steps) { @@ -1202,10 +1206,8 @@ static void About () static Pipeline GetStandardPipeline () { Pipeline p = new Pipeline (); - p.AppendStep (new LoadReferencesStep ()); p.AppendStep (new BlacklistStep ()); p.AppendStep (new DynamicDependencyLookupStep ()); - p.AppendStep (new TypeMapStep ()); p.AppendStep (new MarkStep ()); p.AppendStep (new ValidateVirtualMethodAnnotationsStep ()); p.AppendStep (new ProcessWarningsStep ()); @@ -1214,6 +1216,8 @@ static Pipeline GetStandardPipeline () p.AppendStep (new CleanStep ()); p.AppendStep (new RegenerateGuidStep ()); p.AppendStep (new OutputStep ()); + p.AppendAssemblyStep (new LoadReferencesStep ()); + p.AppendAssemblyStep (new TypeMapStep ()); return p; } diff --git a/src/linker/Linker/LinkContext.cs b/src/linker/Linker/LinkContext.cs index 1db88469cb02..4badc9c94249 100644 --- a/src/linker/Linker/LinkContext.cs +++ b/src/linker/Linker/LinkContext.cs @@ -304,6 +304,15 @@ public TypeDefinition GetType (string fullName) return assembly.MainModule.GetType (fullName); } + // Run the per-assembly logic on a new assembly. + // Each step may modify the context of assemblies passed to the next. + public void ProcessReferenceClosure (AssemblyDefinition assembly) + { + var assemblies = new HashSet { assembly }; + foreach (var step in Pipeline.GetAssemblySteps ()) + step.ProcessAssemblies (assemblies); + } + public AssemblyDefinition Resolve (string name) { if (File.Exists (name)) { diff --git a/src/linker/Linker/Pipeline.cs b/src/linker/Linker/Pipeline.cs index 0aa5a3d1ae8b..82697e316c9d 100644 --- a/src/linker/Linker/Pipeline.cs +++ b/src/linker/Linker/Pipeline.cs @@ -38,10 +38,12 @@ public class Pipeline { readonly List _steps; + readonly List _assemblySteps; public Pipeline () { _steps = new List (); + _assemblySteps = new List (); } public void PrependStep (IStep step) @@ -54,6 +56,11 @@ public void AppendStep (IStep step) _steps.Add (step); } + public void AppendAssemblyStep (IAssemblyStep step) + { + _assemblySteps.Add (step); + } + public void AddStepBefore (Type target, IStep step) { for (int i = 0; i < _steps.Count; i++) { @@ -123,6 +130,9 @@ public void RemoveStep (Type target) public void Process (LinkContext context) { + foreach (var step in _assemblySteps) + step.Initialize (context); + while (_steps.Count > 0) { IStep step = _steps[0]; ProcessStep (context, step); @@ -140,6 +150,11 @@ public IStep[] GetSteps () return _steps.ToArray (); } + public IAssemblyStep[] GetAssemblySteps () + { + return _assemblySteps.ToArray (); + } + public bool ContainsStep (Type type) { foreach (IStep step in _steps) diff --git a/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs b/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs index 4dc91982e7e1..8312e297cefe 100644 --- a/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs +++ b/test/Mono.Linker.Tests.Cases/Attributes/CoreLibraryAssemblyAttributesAreKept.cs @@ -7,6 +7,9 @@ namespace Mono.Linker.Tests.Cases.Attributes { [Reference ("System.dll")] [SetupLinkerCoreAction ("link")] + // IComponent has TypeConverterAttribute referencing System.dll, which has + // unresolved references to Win32 assemblies. + [SetupLinkerArgument ("--skip-unresolved", "true")] [KeptAttributeInAssembly (PlatformAssemblies.CoreLib, typeof (AssemblyDescriptionAttribute))] [KeptAttributeInAssembly (PlatformAssemblies.CoreLib, typeof (AssemblyCompanyAttribute))] #if !NETCOREAPP diff --git a/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs b/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs index 133e92b686d2..3f69eb9384ea 100644 --- a/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs +++ b/test/Mono.Linker.Tests.Cases/CoreLink/CopyOfCoreLibrariesKeepsUnusedTypes.cs @@ -5,6 +5,9 @@ namespace Mono.Linker.Tests.Cases.CoreLink { [SetupLinkerCoreAction ("copy")] + // Color has TypeConverterAttribute referencing System.Drawing.dll, which has + // unresolved reference to System.Drawing.Common. + [SetupLinkerArgument ("--skip-unresolved")] [KeptAssembly (PlatformAssemblies.CoreLib)] [KeptAllTypesAndMembersInAssembly (PlatformAssemblies.CoreLib)] diff --git a/test/Mono.Linker.Tests.Cases/DynamicDependencies/Dependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary.cs b/test/Mono.Linker.Tests.Cases/DynamicDependencies/Dependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary.cs index 58d60c825b77..2aeca1b61fa4 100644 --- a/test/Mono.Linker.Tests.Cases/DynamicDependencies/Dependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary.cs +++ b/test/Mono.Linker.Tests.Cases/DynamicDependencies/Dependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary.cs @@ -11,7 +11,7 @@ public override string Method () return "Dependency"; } - [DynamicDependency (".ctor()", "Mono.Linker.Tests.Cases.Advanced.Dependencies.DynamicDependencyMethodInNonReferencedAssemblyBase2", "base2")] + [DynamicDependency ("#ctor()", "Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies.DynamicDependencyMethodInNonReferencedAssemblyBase2", "base2")] public static void Dependency () { } diff --git a/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssembly.cs b/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssembly.cs index c92206bcdbd7..35dd9b9573ec 100644 --- a/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssembly.cs +++ b/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssembly.cs @@ -1,5 +1,4 @@ using System.Diagnostics.CodeAnalysis; -using System.Runtime.CompilerServices; using Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies; using Mono.Linker.Tests.Cases.Expectations.Assertions; using Mono.Linker.Tests.Cases.Expectations.Metadata; diff --git a/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChained.cs b/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChained.cs index b73048b63342..3f43c89602cc 100644 --- a/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChained.cs +++ b/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChained.cs @@ -1,12 +1,10 @@ using System.Diagnostics.CodeAnalysis; -using System.Runtime.CompilerServices; using Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies; using Mono.Linker.Tests.Cases.Expectations.Assertions; using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DynamicDependencies { - [IgnoreTestCase ("Currently failing")] [SetupCompileBefore ("base.dll", new[] { "Dependencies/DynamicDependencyMethodInNonReferencedAssemblyBase.cs" })] [SetupCompileBefore ("base2.dll", new[] { "Dependencies/DynamicDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new[] { "base.dll" }, addAsReference: false)] [SetupCompileBefore ("library.dll", new[] { "Dependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)] @@ -26,7 +24,7 @@ public static void Main () } [Kept] - [DynamicDependency (".ctor()", "Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies.DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary", "library")] + [DynamicDependency ("#ctor()", "Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies.DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary", "library")] static void Dependency () { } diff --git a/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedReference.cs b/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedReference.cs index f6ee655ec6ff..32fd60d5f8b8 100644 --- a/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedReference.cs +++ b/test/Mono.Linker.Tests.Cases/DynamicDependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedReference.cs @@ -1,12 +1,10 @@ using System.Diagnostics.CodeAnalysis; -using System.Runtime.CompilerServices; using Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies; using Mono.Linker.Tests.Cases.Expectations.Assertions; using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DynamicDependencies { - [IgnoreTestCase ("Currently failing")] [SetupCompileBefore ("base.dll", new[] { "Dependencies/DynamicDependencyMethodInNonReferencedAssemblyBase.cs" })] [SetupCompileBefore ("base2.dll", new[] { "Dependencies/DynamicDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new[] { "base.dll" }, addAsReference: false)] [SetupCompileBefore ("reference.dll", new[] { "Dependencies/DynamicDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)] @@ -29,7 +27,7 @@ public static void Main () } [Kept] - [DynamicDependency (".ctor()", "Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies.DynamicDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary", "library")] + [DynamicDependency ("#ctor()", "Mono.Linker.Tests.Cases.DynamicDependencies.Dependencies.DynamicDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary", "library")] static void Dependency () { } diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs index 69897dc76f7a..82d25dd6f1ff 100644 --- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs +++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs @@ -10,7 +10,7 @@ public override string Method () return "Dependency"; } - [PreserveDependency (".ctor()", "Mono.Linker.Tests.Cases.Advanced.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyBase2", "base2")] + [PreserveDependency (".ctor()", "Mono.Linker.Tests.Cases.PreserveDependencies.Dependencies.PreserveDependencyMethodInNonReferencedAssemblyBase2", "base2")] public static void Dependency () { } diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyErrorCases.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyErrorCases.cs index 2adca1e4e137..ffad45b3a42d 100644 --- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyErrorCases.cs +++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyErrorCases.cs @@ -1,5 +1,4 @@ -using System; -using System.Runtime.CompilerServices; +using System.Runtime.CompilerServices; using Mono.Linker.Tests.Cases.Expectations.Assertions; using Mono.Linker.Tests.Cases.Expectations.Metadata; diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs index 9d7f9f584640..32314c0ae40e 100644 --- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs +++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChained.cs @@ -5,11 +5,10 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies { - [IgnoreTestCase ("Currently failing")] [SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })] [SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })] [SetupCompileBefore ("base2.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new[] { "base.dll" }, addAsReference: false)] - [SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)] + [SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll", "FakeSystemAssembly.dll" }, addAsReference: false)] [KeptAssembly ("base.dll")] [KeptAssembly ("base2.dll")] [KeptAssembly ("library.dll")] diff --git a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs index 105ace452a91..754c0f4e71e0 100644 --- a/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs +++ b/test/Mono.Linker.Tests.Cases/PreserveDependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReference.cs @@ -5,11 +5,10 @@ namespace Mono.Linker.Tests.Cases.PreserveDependencies { - [IgnoreTestCase ("Currently failing")] [SetupCompileBefore ("FakeSystemAssembly.dll", new[] { "Dependencies/PreserveDependencyAttribute.cs" })] [SetupCompileBefore ("base.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase.cs" })] [SetupCompileBefore ("base2.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyBase2.cs" }, references: new[] { "base.dll" }, addAsReference: false)] - [SetupCompileBefore ("reference.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll" }, addAsReference: false)] + [SetupCompileBefore ("reference.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedLibrary.cs" }, references: new[] { "base.dll", "FakeSystemAssembly.dll" }, addAsReference: false)] [SetupCompileBefore ("library.dll", new[] { "Dependencies/PreserveDependencyMethodInNonReferencedAssemblyChainedReferenceLibrary.cs" }, references: new[] { "base.dll", "reference.dll" }, addAsReference: false)] [KeptAssembly ("base.dll")] [KeptAssembly ("base2.dll")] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs index 99a5ecbf8d7a..303c2e3ae0e7 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflection.cs @@ -5,7 +5,6 @@ namespace Mono.Linker.Tests.Cases.Reflection { - [IgnoreTestCase ("Requires support for using a type in an unreferences assembly via reflection")] [SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)] [KeptAssembly ("library.dll")] [KeptTypeInAssembly ("library.dll", "Mono.Linker.Tests.Cases.Reflection.Dependencies.AssemblyDependency")] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs index b5ba1746130a..6cd6beaddf19 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithDerivedType.cs @@ -5,7 +5,6 @@ namespace Mono.Linker.Tests.Cases.Reflection { - [IgnoreTestCase ("Requires support for using a type in an unreferences assembly via reflection")] [SetupCompileBefore ("base.dll", new[] { "Dependencies/AssemblyImportedViaReflectionWithDerivedType_Base.cs" })] [SetupCompileBefore ("reflection.dll", new[] { "Dependencies/AssemblyImportedViaReflectionWithDerivedType_Reflect.cs" }, references: new[] { "base.dll" }, addAsReference: false)] [KeptAssembly ("base.dll")] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs index 0cdb848e3534..ab4bc5c634ca 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithReference.cs @@ -4,7 +4,6 @@ namespace Mono.Linker.Tests.Cases.Reflection { - [IgnoreTestCase ("Requires support for using a type in an unreferences assembly via reflection")] [SetupCompileBefore ("reference.dll", new[] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)] [SetupCompileBefore ("library.dll", new[] { "Dependencies/AssemblyDependencyWithReference.cs" }, references: new[] { "reference.dll" }, addAsReference: false)] [KeptAssembly ("reference.dll")]