public UsageBasedMetadataManager(
CompilationModuleGroup group,
CompilerTypeSystemContext typeSystemContext,
MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy,
string logFile,
StackTraceEmissionPolicy stackTracePolicy,
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy,
FlowAnnotations flowAnnotations,
UsageBasedMetadataGenerationOptions generationOptions,
Logger logger,
IEnumerable <KeyValuePair <string, bool> > featureSwitchValues,
IEnumerable <string> rootEntireAssembliesModules,
IEnumerable <string> trimmedAssemblies)
: base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, logFile, stackTracePolicy, invokeThunkGenerationPolicy)
{
// We use this to mark places that would behave differently if we tracked exact fields used.
_hasPreciseFieldUsageInformation = false;
_compilationModuleGroup = group;
_generationOptions = generationOptions;
FlowAnnotations = flowAnnotations;
Logger = logger;
_featureSwitchHashtable = new FeatureSwitchHashtable(new Dictionary <string, bool>(featureSwitchValues));
_rootEntireAssembliesModules = new HashSet <string>(rootEntireAssembliesModules);
_trimmedAssemblies = new HashSet <string>(trimmedAssemblies);
}
public MetadataManager(CompilerTypeSystemContext typeSystemContext, MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy, DynamicInvokeThunkGenerationPolicy dynamicInvokeThunkGenerationPolicy)
{
_typeSystemContext = typeSystemContext;
_blockingPolicy = blockingPolicy;
_resourceBlockingPolicy = resourceBlockingPolicy;
_dynamicInvokeThunkGenerationPolicy = dynamicInvokeThunkGenerationPolicy;
}
public GeneratingMetadataManager(CompilerTypeSystemContext typeSystemContext, MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy, string logFile, StackTraceEmissionPolicy stackTracePolicy,
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy)
: base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, invokeThunkGenerationPolicy)
{
_metadataLogFile = logFile;
_stackTraceEmissionPolicy = stackTracePolicy;
_generatedAssembly = typeSystemContext.GeneratedAssembly;
}
public UsageBasedMetadataManager(
CompilationModuleGroup group,
CompilerTypeSystemContext typeSystemContext,
MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy,
string logFile,
StackTraceEmissionPolicy stackTracePolicy)
: base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, logFile, stackTracePolicy)
{
// We use this to mark places that would behave differently if we tracked exact fields used.
_hasPreciseFieldUsageInformation = false;
_compilationModuleGroup = group;
}
public UsageBasedMetadataManager(
CompilationModuleGroup group,
CompilerTypeSystemContext typeSystemContext,
MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy,
string logFile,
StackTraceEmissionPolicy stackTracePolicy,
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy,
UsageBasedMetadataGenerationOptions generationOptions)
: base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, logFile, stackTracePolicy, invokeThunkGenerationPolicy)
{
// We use this to mark places that would behave differently if we tracked exact fields used.
_hasPreciseFieldUsageInformation = false;
_compilationModuleGroup = group;
_generationOptions = generationOptions;
_serializationInfoType = typeSystemContext.SystemModule.GetType("System.Runtime.Serialization", "SerializationInfo", false);
}
private int Run(string[] args)
{
InitializeDefaultOptions();
ArgumentSyntax syntax = ParseCommandLine(args);
if (_help)
{
Help(syntax.GetHelpText());
return(1);
}
if (_outputFilePath == null)
{
throw new CommandLineException("Output filename must be specified (/out <file>)");
}
//
// Set target Architecture and OS
//
if (_targetArchitectureStr != null)
{
if (_targetArchitectureStr.Equals("x86", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.X86;
}
else if (_targetArchitectureStr.Equals("x64", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.X64;
}
else if (_targetArchitectureStr.Equals("arm", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM;
}
else if (_targetArchitectureStr.Equals("armel", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM;
}
else if (_targetArchitectureStr.Equals("arm64", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM64;
}
else if (_targetArchitectureStr.Equals("wasm", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.Wasm32;
_isWasmCodegen = true;
}
else
{
throw new CommandLineException("Target architecture is not supported");
}
}
if (_targetOSStr != null)
{
if (_targetOSStr.Equals("windows", StringComparison.OrdinalIgnoreCase))
{
_targetOS = TargetOS.Windows;
}
else if (_targetOSStr.Equals("linux", StringComparison.OrdinalIgnoreCase))
{
_targetOS = TargetOS.Linux;
}
else if (_targetOSStr.Equals("osx", StringComparison.OrdinalIgnoreCase))
{
_targetOS = TargetOS.OSX;
}
else
{
throw new CommandLineException("Target OS is not supported");
}
}
if (_isWasmCodegen)
{
_targetArchitecture = TargetArchitecture.Wasm32;
}
bool supportsReflection = !_disableReflection && _systemModuleName == DefaultSystemModule;
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics || !_isWasmCodegen ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
// TODO: compiler switch for SIMD support?
var simdVectorLength = (_isCppCodegen || _isWasmCodegen) ? SimdVectorLength.None : SimdVectorLength.Vector128Bit;
var targetAbi = _isCppCodegen ? TargetAbi.CppCodegen : TargetAbi.CoreRT;
var targetDetails = new TargetDetails(_targetArchitecture, _targetOS, targetAbi, simdVectorLength);
CompilerTypeSystemContext typeSystemContext =
new CompilerTypeSystemContext(targetDetails, genericsMode, supportsReflection ? DelegateFeature.All : 0);
//
// TODO: To support our pre-compiled test tree, allow input files that aren't managed assemblies since
// some tests contain a mixture of both managed and native binaries.
//
// See: https://github.com/dotnet/corert/issues/2785
//
// When we undo this this hack, replace this foreach with
// typeSystemContext.InputFilePaths = _inputFilePaths;
//
Dictionary <string, string> inputFilePaths = new Dictionary <string, string>();
foreach (var inputFile in _inputFilePaths)
{
try
{
var module = typeSystemContext.GetModuleFromPath(inputFile.Value);
inputFilePaths.Add(inputFile.Key, inputFile.Value);
}
catch (TypeSystemException.BadImageFormatException)
{
// Keep calm and carry on.
}
}
typeSystemContext.InputFilePaths = inputFilePaths;
typeSystemContext.ReferenceFilePaths = _referenceFilePaths;
typeSystemContext.SetSystemModule(typeSystemContext.GetModuleForSimpleName(_systemModuleName));
if (typeSystemContext.InputFilePaths.Count == 0)
{
throw new CommandLineException("No input files specified");
}
//
// Initialize compilation group and compilation roots
//
// Single method mode?
MethodDesc singleMethod = CheckAndParseSingleMethodModeArguments(typeSystemContext);
CompilationModuleGroup compilationGroup;
List <ICompilationRootProvider> compilationRoots = new List <ICompilationRootProvider>();
if (singleMethod != null)
{
// Compiling just a single method
compilationGroup = new SingleMethodCompilationModuleGroup(singleMethod);
compilationRoots.Add(new SingleMethodRootProvider(singleMethod));
}
else
{
// Either single file, or multifile library, or multifile consumption.
EcmaModule entrypointModule = null;
bool systemModuleIsInputModule = false;
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (module.PEReader.PEHeaders.IsExe)
{
if (entrypointModule != null)
{
throw new Exception("Multiple EXE modules");
}
entrypointModule = module;
}
if (module == typeSystemContext.SystemModule)
{
systemModuleIsInputModule = true;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, CreateInitializerList(typeSystemContext)));
compilationRoots.Add(new RuntimeConfigurationRootProvider(_runtimeOptions));
}
if (_multiFile)
{
List <EcmaModule> inputModules = new List <EcmaModule>();
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (entrypointModule == null)
{
// This is a multifile production build - we need to root all methods
compilationRoots.Add(new LibraryRootProvider(module));
}
inputModules.Add(module);
}
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
if (entrypointModule == null && !_nativeLib)
{
throw new Exception("No entrypoint module");
}
if (!systemModuleIsInputModule)
{
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
}
compilationGroup = new SingleFileCompilationModuleGroup();
}
if (_nativeLib)
{
// Set owning module of generated native library startup method to compiler generated module,
// to ensure the startup method is included in the object file during multimodule mode build
compilationRoots.Add(new NativeLibraryInitializerRootProvider(typeSystemContext.GeneratedAssembly, CreateInitializerList(typeSystemContext)));
compilationRoots.Add(new RuntimeConfigurationRootProvider(_runtimeOptions));
}
if (_rdXmlFilePaths.Count > 0)
{
Console.WriteLine("Warning: RD.XML processing will change before release (https://github.com/dotnet/corert/issues/5001)");
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isWasmCodegen)
{
builder = new WebAssemblyCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
string compilationUnitPrefix = _multiFile ? System.IO.Path.GetFileNameWithoutExtension(_outputFilePath) : "";
builder.UseCompilationUnitPrefix(compilationUnitPrefix);
PInvokeILEmitterConfiguration pinvokePolicy;
if (!_isCppCodegen && !_isWasmCodegen)
{
pinvokePolicy = new ConfigurablePInvokePolicy(typeSystemContext.Target);
}
else
{
pinvokePolicy = new DirectPInvokePolicy();
}
RemovedFeature removedFeatures = 0;
foreach (string feature in _removedFeatures)
{
if (feature == "EventSource")
{
removedFeatures |= RemovedFeature.Etw;
}
else if (feature == "FrameworkStrings")
{
removedFeatures |= RemovedFeature.FrameworkResources;
}
else if (feature == "Globalization")
{
removedFeatures |= RemovedFeature.Globalization;
}
else if (feature == "Comparers")
{
removedFeatures |= RemovedFeature.Comparers;
}
else if (feature == "CurlHandler")
{
removedFeatures |= RemovedFeature.CurlHandler;
}
}
ILProvider ilProvider = new CoreRTILProvider();
if (removedFeatures != 0)
{
ilProvider = new RemovingILProvider(ilProvider, removedFeatures);
}
var stackTracePolicy = _emitStackTraceData ?
(StackTraceEmissionPolicy) new EcmaMethodStackTraceEmissionPolicy() : new NoStackTraceEmissionPolicy();
MetadataBlockingPolicy mdBlockingPolicy = _noMetadataBlocking
? (MetadataBlockingPolicy) new NoMetadataBlockingPolicy()
: new BlockedInternalsBlockingPolicy(typeSystemContext);
ManifestResourceBlockingPolicy resBlockingPolicy = (removedFeatures & RemovedFeature.FrameworkResources) != 0 ?
new FrameworkStringResourceBlockingPolicy() : (ManifestResourceBlockingPolicy) new NoManifestResourceBlockingPolicy();
UsageBasedMetadataGenerationOptions metadataGenerationOptions = UsageBasedMetadataGenerationOptions.AnonymousTypeHeuristic;
if (_completeTypesMetadata)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.CompleteTypesOnly;
}
if (_scanReflection)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.ILScanning;
}
if (_rootAllApplicationAssemblies)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.FullUserAssemblyRooting;
}
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy = new DefaultDynamicInvokeThunkGenerationPolicy();
MetadataManager metadataManager;
if (supportsReflection)
{
metadataManager = new UsageBasedMetadataManager(
compilationGroup,
typeSystemContext,
mdBlockingPolicy,
resBlockingPolicy,
_metadataLogFileName,
stackTracePolicy,
invokeThunkGenerationPolicy,
ilProvider,
metadataGenerationOptions);
}
else
{
metadataManager = new EmptyMetadataManager(typeSystemContext, stackTracePolicy, ilProvider);
}
InteropStateManager interopStateManager = new InteropStateManager(typeSystemContext.GeneratedAssembly);
InteropStubManager interopStubManager = new UsageBasedInteropStubManager(interopStateManager, pinvokePolicy);
// Unless explicitly opted in at the command line, we enable scanner for retail builds by default.
// We don't do this for CppCodegen and Wasm, because those codegens are behind.
// We also don't do this for multifile because scanner doesn't simulate inlining (this would be
// fixable by using a CompilationGroup for the scanner that has a bigger worldview, but
// let's cross that bridge when we get there).
bool useScanner = _useScanner ||
(_optimizationMode != OptimizationMode.None && !_isCppCodegen && !_isWasmCodegen && !_multiFile);
useScanner &= !_noScanner;
builder.UseILProvider(ilProvider);
ILScanResults scanResults = null;
if (useScanner)
{
ILScannerBuilder scannerBuilder = builder.GetILScannerBuilder()
.UseCompilationRoots(compilationRoots)
.UseMetadataManager(metadataManager)
.UseSingleThread(enable: _singleThreaded)
.UseInteropStubManager(interopStubManager);
if (_scanDgmlLogFileName != null)
{
scannerBuilder.UseDependencyTracking(_generateFullScanDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
}
IILScanner scanner = scannerBuilder.ToILScanner();
scanResults = scanner.Scan();
if (metadataManager is UsageBasedMetadataManager usageBasedManager)
{
metadataManager = usageBasedManager.ToAnalysisBasedMetadataManager();
}
else
{
// MetadataManager collects a bunch of state (e.g. list of compiled method bodies) that we need to reset.
Debug.Assert(metadataManager is EmptyMetadataManager);
metadataManager = new EmptyMetadataManager(typeSystemContext, stackTracePolicy, ilProvider);
}
interopStubManager = scanResults.GetInteropStubManager(interopStateManager, pinvokePolicy);
}
var logger = new Logger(Console.Out, _isVerbose);
DebugInformationProvider debugInfoProvider = _enableDebugInfo ?
(_ilDump == null ? new DebugInformationProvider() : new ILAssemblyGeneratingMethodDebugInfoProvider(_ilDump, new EcmaOnlyDebugInformationProvider())) :
new NullDebugInformationProvider();
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
compilationRoots.Add(metadataManager);
compilationRoots.Add(interopStubManager);
builder
.UseBackendOptions(_codegenOptions)
.UseMethodBodyFolding(enable: _methodBodyFolding)
.UseSingleThread(enable: _singleThreaded)
.UseMetadataManager(metadataManager)
.UseInteropStubManager(interopStubManager)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.UseOptimizationMode(_optimizationMode)
.UseDebugInfoProvider(debugInfoProvider);
if (scanResults != null)
{
// If we have a scanner, feed the vtable analysis results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseVTableSliceProvider(scanResults.GetVTableLayoutInfo());
// If we have a scanner, feed the generic dictionary results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseGenericDictionaryLayoutProvider(scanResults.GetDictionaryLayoutInfo());
// If we feed any outputs of the scanner into the compilation, it's essential
// we use scanner's devirtualization manager. It prevents optimizing codegens
// from accidentally devirtualizing cases that can never happen at runtime
// (e.g. devirtualizing a method on a type that never gets allocated).
builder.UseDevirtualizationManager(scanResults.GetDevirtualizationManager());
}
ICompilation compilation = builder.ToCompilation();
ObjectDumper dumper = _mapFileName != null ? new ObjectDumper(_mapFileName) : null;
CompilationResults compilationResults = compilation.Compile(_outputFilePath, dumper);
if (_exportsFile != null)
{
ExportsFileWriter defFileWriter = new ExportsFileWriter(typeSystemContext, _exportsFile);
foreach (var compilationRoot in compilationRoots)
{
if (compilationRoot is ExportedMethodsRootProvider provider)
{
defFileWriter.AddExportedMethods(provider.ExportedMethods);
}
}
defFileWriter.EmitExportedMethods();
}
if (_dgmlLogFileName != null)
{
compilationResults.WriteDependencyLog(_dgmlLogFileName);
}
if (scanResults != null)
{
SimdHelper simdHelper = new SimdHelper();
if (_scanDgmlLogFileName != null)
{
scanResults.WriteDependencyLog(_scanDgmlLogFileName);
}
// If the scanner and compiler don't agree on what to compile, the outputs of the scanner might not actually be usable.
// We are going to check this two ways:
// 1. The methods and types generated during compilation are a subset of method and types scanned
// 2. The methods and types scanned are a subset of methods and types compiled (this has a chance to hold for unoptimized builds only).
// Check that methods and types generated during compilation are a subset of method and types scanned
bool scanningFail = false;
DiffCompilationResults(ref scanningFail, compilationResults.CompiledMethodBodies, scanResults.CompiledMethodBodies,
"Methods", "compiled", "scanned", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || method.Name == "ThrowPlatformNotSupportedException");
DiffCompilationResults(ref scanningFail, compilationResults.ConstructedEETypes, scanResults.ConstructedEETypes,
"EETypes", "compiled", "scanned", type => !(type.GetTypeDefinition() is EcmaType));
// If optimizations are enabled, the results will for sure not match in the other direction due to inlining, etc.
// But there's at least some value in checking the scanner doesn't expand the universe too much in debug.
if (_optimizationMode == OptimizationMode.None)
{
// Check that methods and types scanned are a subset of methods and types compiled
// If we find diffs here, they're not critical, but still might be causing a Size on Disk regression.
bool dummy = false;
// We additionally skip methods in SIMD module because there's just too many intrisics to handle and IL scanner
// doesn't expand them. They would show up as noisy diffs.
DiffCompilationResults(ref dummy, scanResults.CompiledMethodBodies, compilationResults.CompiledMethodBodies,
"Methods", "scanned", "compiled", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || simdHelper.IsSimdType(method.OwningType));
DiffCompilationResults(ref dummy, scanResults.ConstructedEETypes, compilationResults.ConstructedEETypes,
"EETypes", "scanned", "compiled", type => !(type.GetTypeDefinition() is EcmaType));
}
if (scanningFail)
{
throw new Exception("Scanning failure");
}
}
if (debugInfoProvider is IDisposable)
{
((IDisposable)debugInfoProvider).Dispose();
}
return(0);
}
public AnalysisBasedMetadataManager(
CompilerTypeSystemContext typeSystemContext,
MetadataBlockingPolicy blockingPolicy,
ManifestResourceBlockingPolicy resourceBlockingPolicy,
string logFile,
StackTraceEmissionPolicy stackTracePolicy,
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy,
IEnumerable <ModuleDesc> modulesWithMetadata,
IEnumerable <ReflectableEntity <TypeDesc> > reflectableTypes,
IEnumerable <ReflectableEntity <MethodDesc> > reflectableMethods,
IEnumerable <ReflectableEntity <FieldDesc> > reflectableFields,
IEnumerable <TypeDesc> ldtokenReferenceableTypes)
: base(typeSystemContext, blockingPolicy, resourceBlockingPolicy, logFile, stackTracePolicy, invokeThunkGenerationPolicy)
{
_modulesWithMetadata = new List <ModuleDesc>(modulesWithMetadata);
foreach (var refType in reflectableTypes)
{
_reflectableTypes.Add(refType.Entity, refType.Category);
}
foreach (var refMethod in reflectableMethods)
{
// Asking for description or runtime mapping for a member without asking
// for the owning type would mean we can't actually satisfy the request.
Debug.Assert((refMethod.Category & MetadataCategory.Description) == 0 ||
(_reflectableTypes[refMethod.Entity.OwningType] & MetadataCategory.Description) != 0);
Debug.Assert((refMethod.Category & MetadataCategory.RuntimeMapping) == 0 ||
(_reflectableTypes[refMethod.Entity.OwningType] & MetadataCategory.RuntimeMapping) != 0);
_reflectableMethods.Add(refMethod.Entity, refMethod.Category);
}
foreach (var refField in reflectableFields)
{
// Asking for description or runtime mapping for a member without asking
// for the owning type would mean we can't actually satisfy the request.
Debug.Assert((refField.Category & MetadataCategory.Description) == 0 ||
(_reflectableTypes[refField.Entity.OwningType] & MetadataCategory.Description) != 0);
Debug.Assert((refField.Category & MetadataCategory.RuntimeMapping) == 0 ||
(_reflectableTypes[refField.Entity.OwningType] & MetadataCategory.RuntimeMapping) != 0);
_reflectableFields.Add(refField.Entity, refField.Category);
}
_ldtokenReferenceableTypes = new HashSet <TypeDesc>(ldtokenReferenceableTypes);
#if DEBUG
HashSet <ModuleDesc> moduleHash = new HashSet <ModuleDesc>(_modulesWithMetadata);
foreach (var refType in reflectableTypes)
{
// The instantiated types need to agree on the Description bit with the definition.
// GetMetadataCategory relies on that.
Debug.Assert((GetMetadataCategory(refType.Entity.GetTypeDefinition()) & MetadataCategory.Description)
== (GetMetadataCategory(refType.Entity) & MetadataCategory.Description));
Debug.Assert(!(refType.Entity is MetadataType) || moduleHash.Contains(((MetadataType)refType.Entity).Module));
}
foreach (var refMethod in reflectableMethods)
{
// The instantiated methods need to agree on the Description bit with the definition.
// GetMetadataCategory relies on that.
Debug.Assert((GetMetadataCategory(refMethod.Entity.GetTypicalMethodDefinition()) & MetadataCategory.Description)
== (GetMetadataCategory(refMethod.Entity) & MetadataCategory.Description));
// Canonical form of the method needs to agree with the logical form
Debug.Assert(GetMetadataCategory(refMethod.Entity) == GetMetadataCategory(refMethod.Entity.GetCanonMethodTarget(CanonicalFormKind.Specific)));
}
foreach (var refField in reflectableFields)
{
// The instantiated fields need to agree on the Description bit with the definition.
// GetMetadataCategory relies on that.
Debug.Assert((GetMetadataCategory(refField.Entity.GetTypicalFieldDefinition()) & MetadataCategory.Description)
== (GetMetadataCategory(refField.Entity) & MetadataCategory.Description));
}
#endif
}
public MetadataManager(CompilerTypeSystemContext typeSystemContext, MetadataBlockingPolicy blockingPolicy, ManifestResourceBlockingPolicy resourceBlockingPolicy)
{
_typeSystemContext = typeSystemContext;
_blockingPolicy = blockingPolicy;
_resourceBlockingPolicy = resourceBlockingPolicy;
}
