public ReadyToRunHelperKey(ReadyToRunHelperId id, object target, SignatureContext signatureContext)
{
Id = id;
Target = target;
SignatureContext = signatureContext;
}
public override ICompilation ToCompilation()
{
ModuleTokenResolver moduleTokenResolver = new ModuleTokenResolver(_compilationGroup, _context);
SignatureContext signatureContext = new SignatureContext(_inputModule, moduleTokenResolver);
CopiedCorHeaderNode corHeaderNode = new CopiedCorHeaderNode(_inputModule);
AttributePresenceFilterNode attributePresenceFilterNode = null;
// Core library attributes are checked FAR more often than other dlls
// attributes, so produce a highly efficient table for determining if they are
// present. Other assemblies *MAY* benefit from this feature, but it doesn't show
// as useful at this time.
if (_inputModule == _inputModule.Context.SystemModule)
{
attributePresenceFilterNode = new AttributePresenceFilterNode(_inputModule);
}
// Produce a ResourceData where the IBC PROFILE_DATA entry has been filtered out
ResourceData win32Resources = new ResourceData(_inputModule, (object type, object name, ushort language) =>
{
if (!(type is string) || !(name is string))
{
return(true);
}
if (language != 0)
{
return(true);
}
string typeString = (string)type;
string nameString = (string)name;
if ((typeString == "IBC") && (nameString == "PROFILE_DATA"))
{
return(false);
}
return(true);
});
ReadyToRunCodegenNodeFactory factory = new ReadyToRunCodegenNodeFactory(
_context,
_compilationGroup,
_nameMangler,
moduleTokenResolver,
signatureContext,
corHeaderNode,
win32Resources,
attributePresenceFilterNode);
IComparer <DependencyNodeCore <NodeFactory> > comparer = new SortableDependencyNode.ObjectNodeComparer(new CompilerComparer());
DependencyAnalyzerBase <NodeFactory> graph = CreateDependencyGraph(factory, comparer);
List <CorJitFlag> corJitFlags = new List <CorJitFlag> {
CorJitFlag.CORJIT_FLAG_DEBUG_INFO
};
switch (_optimizationMode)
{
case OptimizationMode.None:
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_DEBUG_CODE);
break;
case OptimizationMode.PreferSize:
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SIZE_OPT);
break;
case OptimizationMode.PreferSpeed:
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SPEED_OPT);
break;
default:
// Not setting a flag results in BLENDED_CODE.
break;
}
if (_ibcTuning)
{
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_BBINSTR);
}
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_FEATURE_SIMD);
var jitConfig = new JitConfigProvider(corJitFlags, _ryujitOptions, _jitPath);
return(new ReadyToRunCodegenCompilation(
graph,
factory,
_compilationRoots,
_ilProvider,
_logger,
new DependencyAnalysis.ReadyToRun.DevirtualizationManager(_compilationGroup),
jitConfig,
_inputFilePath,
new ModuleDesc[] { _inputModule },
_resilient,
_parallelism));
}
private ISymbolNode CreateFieldHandleHelper(FieldDesc field, SignatureContext signatureContext)
{
return(new PrecodeHelperImport(
_codegenNodeFactory,
new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldHandle, field, signatureContext)));
}
public ISortableSymbolNode MethodGenericDictionary(MethodDesc method, ModuleToken methodToken, SignatureContext signatureContext)
{
if (!_genericDictionaryCache.TryGetValue(method, out ISortableSymbolNode genericDictionary))
{
genericDictionary = new PrecodeHelperMethodImport(
_codegenNodeFactory,
method,
_codegenNodeFactory.MethodSignature(
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodDictionary,
method,
constrainedType: null,
methodToken: methodToken,
signatureContext: signatureContext,
isUnboxingStub: false,
isInstantiatingStub: true));
_genericDictionaryCache.Add(method, genericDictionary);
}
return(genericDictionary);
}
public ISymbolNode GenericLookupHelper(
CORINFO_RUNTIME_LOOKUP_KIND runtimeLookupKind,
ReadyToRunHelperId helperId,
object helperArgument,
TypeDesc constrainedType,
GenericContext methodContext,
SignatureContext signatureContext)
{
switch (helperId)
{
case ReadyToRunHelperId.TypeHandle:
return(GenericLookupTypeHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_TypeHandle,
helperArgument,
methodContext,
signatureContext));
case ReadyToRunHelperId.MethodHandle:
return(GenericLookupMethodHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodHandle,
(MethodWithToken)helperArgument,
constrainedType,
methodContext,
signatureContext));
case ReadyToRunHelperId.MethodEntry:
return(GenericLookupMethodHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodEntry,
(MethodWithToken)helperArgument,
constrainedType,
methodContext,
signatureContext));
case ReadyToRunHelperId.MethodDictionary:
return(GenericLookupMethodHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_MethodHandle,
(MethodWithToken)helperArgument,
constrainedType,
methodContext,
signatureContext));
case ReadyToRunHelperId.TypeDictionary:
return(GenericLookupTypeHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_TypeDictionary,
(TypeDesc)helperArgument,
methodContext,
signatureContext));
case ReadyToRunHelperId.VirtualDispatchCell:
return(GenericLookupMethodHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry,
(MethodWithToken)helperArgument,
constrainedType,
methodContext,
signatureContext));
case ReadyToRunHelperId.FieldHandle:
return(GenericLookupFieldHelper(
runtimeLookupKind,
ReadyToRunFixupKind.READYTORUN_FIXUP_FieldHandle,
(FieldDesc)helperArgument,
methodContext,
signatureContext));
default:
throw new NotImplementedException(helperId.ToString());
}
}
protected override JObject Process(string method, JArray _params)
{
switch (method)
{
case "getbalance":
if (Program.Wallet == null)
{
throw new RpcException(-400, "Access denied.");
}
else
{
UInt256 assetId = UInt256.Parse(_params[0].AsString());
IEnumerable <Coin> coins = Program.Wallet.GetCoins().Where(p => !p.State.HasFlag(CoinState.Spent) && p.Output.AssetId.Equals(assetId));
JObject json = new JObject();
json["balance"] = coins.Sum(p => p.Output.Value).ToString();
json["confirmed"] = coins.Where(p => p.State.HasFlag(CoinState.Confirmed)).Sum(p => p.Output.Value).ToString();
return(json);
}
case "sendtoaddress":
if (Program.Wallet == null)
{
throw new RpcException(-400, "Access denied");
}
else
{
UInt256 assetId = UInt256.Parse(_params[0].AsString());
UInt160 scriptHash = Wallet.ToScriptHash(_params[1].AsString());
Fixed8 value = Fixed8.Parse(_params[2].AsString());
Fixed8 fee = _params.Count >= 4 ? Fixed8.Parse(_params[3].AsString()) : Fixed8.Zero;
if (value <= Fixed8.Zero)
{
throw new RpcException(-32602, "Invalid params");
}
ContractTransaction tx = Program.Wallet.MakeTransaction(new ContractTransaction
{
Outputs = new[]
{
new TransactionOutput
{
AssetId = assetId,
Value = value,
ScriptHash = scriptHash
}
}
}, fee: fee);
if (tx == null)
{
throw new RpcException(-300, "Insufficient funds");
}
SignatureContext context = new SignatureContext(tx);
Program.Wallet.Sign(context);
if (context.Completed)
{
tx.Scripts = context.GetScripts();
Program.Wallet.SaveTransaction(tx);
LocalNode.Relay(tx);
return(tx.ToJson());
}
else
{
return(context.ToJson());
}
}
default:
return(base.Process(method, _params));
}
}
public ISymbolNode InterfaceDispatchCell(MethodDesc method, ModuleToken methodToken, SignatureContext signatureContext, bool isUnboxingStub, string callSite)
{
MethodAndCallSite cellKey = new MethodAndCallSite(method, callSite);
if (!_interfaceDispatchCells.TryGetValue(cellKey, out ISymbolNode dispatchCell))
{
dispatchCell = new DelayLoadHelperMethodImport(
_codegenNodeFactory,
_codegenNodeFactory.DispatchImports,
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_MethodCall |
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_FLAG_VSD,
new MethodWithToken(method, methodToken),
useInstantiatingStub: false,
_codegenNodeFactory.MethodSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry, method,
null, methodToken, isUnboxingStub, isInstantiatingStub: false, signatureContext),
signatureContext,
callSite);
_interfaceDispatchCells.Add(cellKey, dispatchCell);
}
return(dispatchCell);
}
public ISymbolNode FieldBaseOffset(TypeDesc typeDesc, SignatureContext signatureContext)
{
return(_fieldBaseOffsetCache.GetOrAdd(new TypeAndSignatureContext(typeDesc, signatureContext)));
}
public ISymbolNode InterfaceDispatchCell(MethodWithToken method, SignatureContext signatureContext, bool isUnboxingStub, string callSite)
{
MethodAndCallSite cellKey = new MethodAndCallSite(method, isUnboxingStub, callSite, signatureContext);
return(_interfaceDispatchCells.GetOrAdd(cellKey));
}
public TypeAndSignatureContext(TypeDesc typeDesc, SignatureContext signatureContext)
{
Type = typeDesc;
SignatureContext = signatureContext;
}
private void CreateNodeCaches()
{
_importStrings = new NodeCache <ModuleTokenAndSignatureContext, ISymbolNode>(key =>
{
return(new StringImport(_codegenNodeFactory.StringImports, key.ModuleToken, key.SignatureContext));
});
_r2rHelpers = new NodeCache <ReadyToRunHelperKey, ISymbolNode>(CreateReadyToRunHelper);
_fieldAddressCache = new NodeCache <FieldAndSignatureContext, ISymbolNode>(key =>
{
return(new DelayLoadHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.HelperImports,
ILCompiler.ReadyToRunHelper.DelayLoad_Helper,
new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldAddress, key.Field, key.SignatureContext)
));
});
_fieldOffsetCache = new NodeCache <FieldAndSignatureContext, ISymbolNode>(key =>
{
return(new PrecodeHelperImport(
_codegenNodeFactory,
new FieldFixupSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldOffset, key.Field, key.SignatureContext)
));
});
_fieldBaseOffsetCache = new NodeCache <TypeAndSignatureContext, ISymbolNode>(key =>
{
return(new PrecodeHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_FieldBaseOffset, key.Type, key.SignatureContext)
));
});
_interfaceDispatchCells = new NodeCache <MethodAndCallSite, ISymbolNode>(cellKey =>
{
return(new DelayLoadHelperMethodImport(
_codegenNodeFactory,
_codegenNodeFactory.DispatchImports,
ILCompiler.ReadyToRunHelper.DelayLoad_MethodCall,
cellKey.Method,
useVirtualCall: true,
useInstantiatingStub: false,
_codegenNodeFactory.MethodSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_VirtualEntry,
cellKey.Method,
cellKey.IsUnboxingStub, isInstantiatingStub: false, cellKey.SignatureContext),
cellKey.SignatureContext,
cellKey.CallSite));
});
_delegateCtors = new NodeCache <TypeAndMethod, ISymbolNode>(ctorKey =>
{
SignatureContext signatureContext = ctorKey.SignatureContext;
IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint(
ctorKey.Method,
isUnboxingStub: false,
isInstantiatingStub: false,
isPrecodeImportRequired: false,
signatureContext: signatureContext);
return(new DelayLoadHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.HelperImports,
ILCompiler.ReadyToRunHelper.DelayLoad_Helper,
new DelegateCtorSignature(ctorKey.Type, targetMethodNode, ctorKey.Method.Token, signatureContext)));
});
_genericLookupHelpers = new NodeCache <GenericLookupKey, ISymbolNode>(key =>
{
return(new DelayLoadHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.HelperImports,
ILCompiler.ReadyToRunHelper.DelayLoad_Helper,
new GenericLookupSignature(
key.LookupKind,
key.FixupKind,
key.TypeArgument,
key.MethodArgument,
key.FieldArgument,
key.MethodContext,
key.SignatureContext)));
});
_indirectPInvokeTargetNodes = new NodeCache <IndirectPInvokeTargetKey, ISymbolNode>(key =>
{
return(new PrecodeHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.MethodSignature(
ReadyToRunFixupKind.READYTORUN_FIXUP_IndirectPInvokeTarget,
key.MethodWithToken,
signatureContext: key.SignatureContext,
isUnboxingStub: false,
isInstantiatingStub: false)));
});
}
public ISymbolNode FieldOffset(FieldDesc fieldDesc, SignatureContext signatureContext)
{
return(_fieldOffsetCache.GetOrAdd(new FieldAndSignatureContext(fieldDesc, signatureContext)));
}
public FieldAndSignatureContext(FieldDesc fieldDesc, SignatureContext signatureContext)
{
Field = fieldDesc;
SignatureContext = signatureContext;
}
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext)
{
return(_r2rHelpers.GetOrAdd(new ReadyToRunHelperKey(id, target, signatureContext)));
}
public DynamicHelperCellKey(MethodWithToken method, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext)
{
Method = method;
IsUnboxingStub = isUnboxingStub;
IsInstantiatingStub = isInstantiatingStub;
SignatureContext = signatureContext;
}
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodWithToken method, SignatureContext signatureContext)
{
TypeAndMethod ctorKey = new TypeAndMethod(
delegateType,
method,
isUnboxingStub: false,
isInstantiatingStub: false,
isPrecodeImportRequired: false,
signatureContext);
return(_delegateCtors.GetOrAdd(ctorKey));
}
public ISymbolNode DynamicHelperCell(MethodWithToken methodWithToken, bool isInstantiatingStub, SignatureContext signatureContext)
{
DynamicHelperCellKey key = new DynamicHelperCellKey(methodWithToken, isUnboxingStub: false, isInstantiatingStub, signatureContext);
return(_dynamicHelperCellCache.GetOrAdd(key));
}
public MethodAndCallSite(MethodWithToken method, bool isUnboxingStub, string callSite, SignatureContext signatureContext)
{
CallSite = callSite;
IsUnboxingStub = isUnboxingStub;
Method = method;
SignatureContext = signatureContext;
}
public ISymbolNode ReadyToRunHelper(ReadyToRunHelperId id, object target, SignatureContext signatureContext)
{
if (!_r2rHelpers.TryGetValue(id, out Dictionary <object, ISymbolNode> helperNodeMap))
{
helperNodeMap = new Dictionary <object, ISymbolNode>();
_r2rHelpers.Add(id, helperNodeMap);
}
if (helperNodeMap.TryGetValue(target, out ISymbolNode helperNode))
{
return(helperNode);
}
switch (id)
{
case ReadyToRunHelperId.NewHelper:
helperNode = CreateNewHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.NewArr1:
helperNode = CreateNewArrayHelper((ArrayType)target, signatureContext);
break;
case ReadyToRunHelperId.GetGCStaticBase:
helperNode = CreateGCStaticBaseHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.GetNonGCStaticBase:
helperNode = CreateNonGCStaticBaseHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.GetThreadStaticBase:
helperNode = CreateThreadGcStaticBaseHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.GetThreadNonGcStaticBase:
helperNode = CreateThreadNonGcStaticBaseHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.IsInstanceOf:
helperNode = CreateIsInstanceOfHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.CastClass:
helperNode = CreateCastClassHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.TypeHandle:
helperNode = CreateTypeHandleHelper((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.MethodHandle:
helperNode = CreateMethodHandleHelper((MethodWithToken)target, signatureContext);
break;
case ReadyToRunHelperId.FieldHandle:
helperNode = CreateFieldHandleHelper((FieldDesc)target, signatureContext);
break;
case ReadyToRunHelperId.VirtualCall:
helperNode = CreateVirtualCallHelper((MethodWithToken)target, signatureContext);
break;
case ReadyToRunHelperId.DelegateCtor:
helperNode = CreateDelegateCtorHelper((DelegateCreationInfo)target, signatureContext);
break;
case ReadyToRunHelperId.CctorTrigger:
helperNode = CreateCctorTrigger((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.TypeDictionary:
helperNode = CreateTypeDictionary((TypeDesc)target, signatureContext);
break;
case ReadyToRunHelperId.MethodDictionary:
helperNode = CreateMethodDictionary((MethodWithToken)target, signatureContext);
break;
default:
throw new NotImplementedException(id.ToString());
}
helperNodeMap.Add(target, helperNode);
return(helperNode);
}
public IndirectPInvokeTargetKey(MethodWithToken methodWithToken, SignatureContext signatureContext)
{
MethodWithToken = methodWithToken;
SignatureContext = signatureContext;
}
public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId helperId, object entity, SignatureContext signatureContext)
{
return(ReadyToRunHelper(helperId, entity, signatureContext));
}
public ISymbolNode GetIndirectPInvokeTargetNode(MethodWithToken methodWithToken, SignatureContext signatureContext)
{
return(_indirectPInvokeTargetNodes.GetOrAdd(new IndirectPInvokeTargetKey(methodWithToken, signatureContext)));
}
public ISymbolNode DelegateCtor(TypeDesc delegateType, MethodDesc targetMethod, ModuleToken methodToken, SignatureContext signatureContext)
{
TypeAndMethod ctorKey = new TypeAndMethod(delegateType, targetMethod, methodToken: methodToken, isUnboxingStub: false, isInstantiatingStub: false);
if (!_delegateCtors.TryGetValue(ctorKey, out ISymbolNode ctorNode))
{
IMethodNode targetMethodNode = _codegenNodeFactory.MethodEntrypoint(
targetMethod,
constrainedType: null,
originalMethod: null,
methodToken: methodToken,
isUnboxingStub: false,
isInstantiatingStub: false,
signatureContext: signatureContext);
ctorNode = new DelayLoadHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.HelperImports,
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_DelayLoad_Helper,
new DelegateCtorSignature(delegateType, targetMethodNode, methodToken, signatureContext));
_delegateCtors.Add(ctorKey, ctorNode);
}
return(ctorNode);
}
private MethodWithGCInfo CreateMethodEntrypointNodeHelper(MethodWithToken targetMethod, bool isUnboxingStub, bool isInstantiatingStub, SignatureContext signatureContext)
{
Debug.Assert(CompilationModuleGroup.ContainsMethodBody(targetMethod.Method, false));
MethodDesc localMethod = targetMethod.Method.GetCanonMethodTarget(CanonicalFormKind.Specific);
TypeAndMethod localMethodKey = new TypeAndMethod(localMethod.OwningType,
new MethodWithToken(localMethod, default(ModuleToken), constrainedType: null),
isUnboxingStub: false,
isInstantiatingStub: false,
isPrecodeImportRequired: false,
signatureContext);
return(_localMethodCache.GetOrAdd(localMethodKey));
}
public override ICompilation ToCompilation()
{
ModuleTokenResolver moduleTokenResolver = new ModuleTokenResolver(_compilationGroup, _context);
SignatureContext signatureContext = new SignatureContext(_inputModule, moduleTokenResolver);
CopiedCorHeaderNode corHeaderNode = new CopiedCorHeaderNode(_inputModule);
// Produce a ResourceData where the IBC PROFILE_DATA entry has been filtered out
ResourceData win32Resources = new ResourceData(_inputModule, (object type, object name, ushort language) =>
{
if (!(type is string) || !(name is string))
{
return(true);
}
if (language != 0)
{
return(true);
}
string typeString = (string)type;
string nameString = (string)name;
if ((typeString == "IBC") && (nameString == "PROFILE_DATA"))
{
return(false);
}
return(true);
});
ReadyToRunCodegenNodeFactory factory = new ReadyToRunCodegenNodeFactory(
_context,
_compilationGroup,
_nameMangler,
moduleTokenResolver,
signatureContext,
corHeaderNode,
win32Resources);
DependencyAnalyzerBase <NodeFactory> graph = CreateDependencyGraph(factory);
List <CorJitFlag> corJitFlags = new List <CorJitFlag> {
CorJitFlag.CORJIT_FLAG_DEBUG_INFO
};
switch (_optimizationMode)
{
case OptimizationMode.None:
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_DEBUG_CODE);
break;
case OptimizationMode.PreferSize:
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SIZE_OPT);
break;
case OptimizationMode.PreferSpeed:
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_SPEED_OPT);
break;
default:
// Not setting a flag results in BLENDED_CODE.
break;
}
if (_ibcTuning)
{
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_BBINSTR);
}
corJitFlags.Add(CorJitFlag.CORJIT_FLAG_FEATURE_SIMD);
var jitConfig = new JitConfigProvider(corJitFlags, _ryujitOptions);
return(new ReadyToRunCodegenCompilation(
graph,
factory,
_compilationRoots,
_ilProvider,
_logger,
new DependencyAnalysis.ReadyToRun.DevirtualizationManager(_compilationGroup),
jitConfig,
_inputFilePath,
new ModuleDesc[] { _inputModule },
_resilient));
}
public TypeFixupKey(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext)
{
FixupKind = fixupKind;
TypeDesc = typeDesc;
SignatureContext = signatureContext;
}
private ISymbolNode CreateTypeHandleHelper(TypeDesc type, SignatureContext signatureContext)
{
return(new PrecodeHelperImport(
_codegenNodeFactory,
_codegenNodeFactory.TypeSignature(ReadyToRunFixupKind.READYTORUN_FIXUP_TypeHandle, type, signatureContext)));
}
public TypeFixupSignature TypeSignature(ReadyToRunFixupKind fixupKind, TypeDesc typeDesc, SignatureContext signatureContext)
{
TypeFixupKey fixupKey = new TypeFixupKey(fixupKind, typeDesc, signatureContext);
return(_typeSignatures.GetOrAdd(fixupKey));
}
private ISymbolNode CreateDelegateCtorHelper(DelegateCreationInfo info, SignatureContext signatureContext)
{
return(info.Constructor);
}
public ISymbolNode StringLiteral(ModuleToken moduleToken, SignatureContext signatureContext)
{
return(_importStrings.GetOrAdd(new ModuleTokenAndSignatureContext(moduleToken, signatureContext)));
}
