void EmitPopIfNeeded (EmitContext ec)
{
if (add_method.ReturnType == typeof (void))
return;
ec.ig.Emit (OpCodes.Pop);
}
internal override void Emit (EmitContext ec, LocalBuilder local)
{
var member = EmitLoadMember (ec, local);
foreach (var binding in bindings)
binding.Emit (ec, member);
}
internal override void Emit (EmitContext ec, LocalBuilder local)
{
var member = EmitLoadMember (ec, local);
foreach (var initializer in initializers)
initializer.Emit (ec, member);
}
internal override void Emit (EmitContext ec)
{
ec.EmitIsInst (expression, type_operand);
ec.ig.Emit (OpCodes.Ldnull);
ec.ig.Emit (OpCodes.Cgt_Un);
}
private void EmitPopIfNeeded(EmitContext emitContext)
{
if (GetReturnType() == typeof(void) && body.Type != typeof(void))
{
emitContext.ig.Emit(OpCodes.Pop);
}
}
internal override void Emit (EmitContext ec)
{
var ig = ec.ig;
var type = this.Type;
LocalBuilder local = null;
if (type.IsValueType) {
local = ig.DeclareLocal (type);
ig.Emit (OpCodes.Ldloca, local);
if (constructor == null) {
ig.Emit (OpCodes.Initobj, type);
ig.Emit (OpCodes.Ldloc, local);
return;
}
}
ec.EmitCollection (arguments);
if (type.IsValueType) {
ig.Emit (OpCodes.Call, constructor);
ig.Emit (OpCodes.Ldloc, local);
} else
ig.Emit (OpCodes.Newobj, constructor ?? GetDefaultConstructor (type));
}
LocalBuilder EmitLoadField (EmitContext ec, FieldInfo field)
{
var store = ec.ig.DeclareLocal (field.FieldType);
ec.ig.Emit (OpCodes.Ldfld, field);
ec.ig.Emit (OpCodes.Stloc, store);
return store;
}
private void EmitPopIfNeeded(EmitContext emitContext)
{
if (_addMethod.ReturnType == typeof(void))
{
return;
}
emitContext.ig.Emit(OpCodes.Pop);
}
internal LocalBuilder EmitLoadMember (EmitContext ec, LocalBuilder local)
{
ec.EmitLoadSubject (local);
return member.OnFieldOrProperty<LocalBuilder> (
field => EmitLoadField (ec, field),
prop => EmitLoadProperty (ec, prop));
}
void EmitPropertyAccess (EmitContext ec, PropertyInfo property)
{
var getter = property.GetGetMethod (true);
if (!getter.IsStatic)
ec.EmitLoadSubject (expression);
ec.EmitCall (getter);
}
void EmitFieldAccess (EmitContext ec, FieldInfo field)
{
if (!field.IsStatic) {
ec.EmitLoadSubject (expression);
ec.ig.Emit (OpCodes.Ldfld, field);
} else
ec.ig.Emit (OpCodes.Ldsfld, field);
}
internal override void Emit(EmitContext emitContext)
{
_member.OnFieldOrProperty
(
field => EmitFieldAccess(emitContext, field),
prop => EmitPropertyAccess(emitContext, prop)
);
}
void EmitTypeAs (EmitContext ec)
{
var type = this.Type;
ec.EmitIsInst (operand, type);
if (type.IsNullable ())
ec.ig.Emit (OpCodes.Unbox_Any, type);
}
private void EmitPropertyAccess(EmitContext emitContext, PropertyInfo property)
{
var getter = property.GetGetMethod(true);
if (!getter.IsStatic)
{
emitContext.EmitLoadSubject(_expression);
}
emitContext.EmitCall(getter);
}
internal LocalBuilder EmitLoadMember(EmitContext emitContext, LocalBuilder local)
{
emitContext.EmitLoadSubject(local);
return _member.OnFieldOrProperty
(
field => EmitLoadField(emitContext, field),
prop => EmitLoadProperty(emitContext, prop)
);
}
internal override void Emit (EmitContext ec)
{
if (Type.IsNullable ()) {
EmitNullableConstant (ec, Type, value);
return;
}
EmitConstant (ec, Type, value);
}
void EmitPropertyAssignment (EmitContext ec, PropertyInfo property, LocalBuilder local)
{
var setter = property.GetSetMethod (true);
if (setter == null)
throw new InvalidOperationException ();
ec.EmitLoadSubject (local);
expression.Emit (ec);
ec.EmitCall (setter);
}
void EmitNullableConstant (EmitContext ec, Type type, object value)
{
if (value == null) {
var local = ec.ig.DeclareLocal (type);
ec.EmitNullableInitialize (local);
} else {
EmitConstant (ec, type.GetFirstGenericArgument (), value);
ec.EmitNullableNew (type);
}
}
LocalBuilder EmitLoadProperty (EmitContext ec, PropertyInfo property)
{
var getter = property.GetGetMethod (true);
if (getter == null)
throw new NotSupportedException ();
var store = ec.ig.DeclareLocal (property.PropertyType);
ec.EmitCall (getter);
ec.ig.Emit (OpCodes.Stloc, store);
return store;
}
private void EmitNewArrayBounds(EmitContext emitContext, Type type)
{
int rank = _expressions.Count;
emitContext.EmitCollection(_expressions);
if (rank == 1)
{
emitContext.ig.Emit(OpCodes.Newarr, type);
return;
}
emitContext.ig.Emit(OpCodes.Newobj, GetArrayConstructor(type, rank));
}
internal override void Emit(EmitContext emitContext)
{
var ig = emitContext.ig;
if (_expression.Type == typeof(void))
{
ig.Emit(OpCodes.Ldc_I4_0);
return;
}
emitContext.EmitIsInst(_expression, _typeOperand);
ig.Emit(OpCodes.Ldnull);
ig.Emit(OpCodes.Cgt_Un);
}
private void EmitHoistedLocal(EmitContext emitContext, int level, int position)
{
emitContext.EmitScope();
for (int i = 0; i < level; i++)
{
emitContext.EmitParentScope();
}
emitContext.EmitLoadLocals();
emitContext.ig.Emit(OpCodes.Ldc_I4, position);
emitContext.ig.Emit(OpCodes.Ldelem, typeof(object));
emitContext.EmitLoadStrongBoxValue(Type);
}
private void EmitFieldAccess(EmitContext emitContext, FieldInfo field)
{
if (field.IsStatic)
{
emitContext.ig.Emit(OpCodes.Ldsfld, field);
}
else
{
emitContext.EmitLoadSubject(_expression);
emitContext.ig.Emit(OpCodes.Ldfld, field);
}
}
internal override void Emit (EmitContext ec)
{
if (expression.Type == typeof (void)) {
ec.ig.Emit (OpCodes.Ldc_I4_0);
return;
}
ec.EmitIsInst (expression, type_operand);
ec.ig.Emit (OpCodes.Ldnull);
ec.ig.Emit (OpCodes.Cgt_Un);
}
internal override void Emit(EmitContext emitContext)
{
var ig = emitContext.ig;
var false_target = ig.DefineLabel();
var end_target = ig.DefineLabel();
_test.Emit(emitContext);
ig.Emit(OpCodes.Brfalse, false_target);
_ifTrue.Emit(emitContext);
ig.Emit(OpCodes.Br, end_target);
ig.MarkLabel(false_target);
_ifFalse.Emit(emitContext);
ig.MarkLabel(end_target);
}
private void EmitNewArrayInit(EmitContext emitContext, Type type)
{
var size = _expressions.Count;
emitContext.ig.Emit(OpCodes.Ldc_I4, size);
emitContext.ig.Emit(OpCodes.Newarr, type);
for (int i = 0; i < size; i++)
{
emitContext.ig.Emit(OpCodes.Dup);
emitContext.ig.Emit(OpCodes.Ldc_I4, i);
_expressions[i].Emit(emitContext);
emitContext.ig.Emit(OpCodes.Stelem, type);
}
}
void EmitNullableConstant (EmitContext ec, Type type, object value)
{
if (value == null) {
var ig = ec.ig;
var local = ig.DeclareLocal (type);
ig.Emit (OpCodes.Ldloca, local);
ig.Emit (OpCodes.Initobj, type);
ig.Emit (OpCodes.Ldloc, local);
} else {
EmitConstant (ec, type.GetFirstGenericArgument (), value);
ec.EmitNullableNew (type);
}
}
void EmitNewArrayInit (EmitContext ec, Type type)
{
var size = expressions.Count;
ec.ig.Emit (OpCodes.Ldc_I4, size);
ec.ig.Emit (OpCodes.Newarr, type);
for (int i = 0; i < size; i++) {
ec.ig.Emit (OpCodes.Dup);
ec.ig.Emit (OpCodes.Ldc_I4, i);
expressions [i].Emit (ec);
ec.ig.Emit (OpCodes.Stelem, type);
}
}
public override void Emit(EmitContext ec)
{
Label is_null_label = ec.DefineLabel ();
Label end_label = ec.DefineLabel ();
unwrap.EmitCheck (ec);
ec.Emit (OpCodes.Brfalse, is_null_label);
expr.Emit (ec);
ec.Emit (OpCodes.Br, end_label);
ec.MarkLabel (is_null_label);
null_value.Emit (ec);
ec.MarkLabel (end_label);
}
internal override void Emit (EmitContext ec)
{
int position = -1;
if (ec.IsLocalParameter (this, ref position)) {
EmitLocalParameter (ec, position);
return;
}
int level = 0;
if (ec.IsHoistedLocal (this, ref level, ref position)) {
EmitHoistedLocal (ec, level, position);
return;
}
throw new InvalidOperationException ("Parameter out of scope");
}
internal static void GetConsolidatedTypeArguments(this ITypeReference typeReference, ArrayBuilder <ITypeReference> consolidatedTypeArguments, EmitContext context)
{
INestedTypeReference nestedTypeReference = typeReference.AsNestedTypeReference;
nestedTypeReference?.GetContainingType(context).GetConsolidatedTypeArguments(consolidatedTypeArguments, context);
IGenericTypeInstanceReference genTypeInstance = typeReference.AsGenericTypeInstanceReference;
if (genTypeInstance != null)
{
consolidatedTypeArguments.AddRange(genTypeInstance.GetGenericArguments(context));
}
}
/// <summary> /// A reference to the constructor that will be used to instantiate this custom attribute during execution (if the attribute is inspected via Reflection). /// </summary> public Cci.IMethodReference Constructor(EmitContext context) => _sourceAttribute.Constructor(context);
public MatchDefsToMetadata(EmitContext sourceContext, PEAssemblySymbol otherAssembly) :
base(sourceContext)
{
_otherAssembly = otherAssembly;
}
Cci.ITypeReference Cci.ITypeDefinition.GetBaseClass(EmitContext context)
{
return(GetBaseClass((TPEModuleBuilder)context.Module, (TSyntaxNode)context.SyntaxNodeOpt, context.Diagnostics));
}
public override IEnumerable <Cci.INamespaceTypeDefinition> GetTopLevelTypeDefinitions(EmitContext context)
{
Cci.TypeReferenceIndexer typeReferenceIndexer = null;
HashSet <string> names;
// First time through, we need to collect emitted names of all top level types.
if (_namesOfTopLevelTypes == null)
{
names = new HashSet <string>();
}
else
{
names = null;
}
// First time through, we need to push things through TypeReferenceIndexer
// to make sure we collect all to be embedded NoPia types and members.
if (EmbeddedTypesManagerOpt != null && !EmbeddedTypesManagerOpt.IsFrozen)
{
typeReferenceIndexer = new Cci.TypeReferenceIndexer(context);
Debug.Assert(names != null);
// Run this reference indexer on the assembly- and module-level attributes first.
// We'll run it on all other types below.
// The purpose is to trigger Translate on all types.
Dispatch(typeReferenceIndexer);
}
AddTopLevelType(names, RootModuleType);
VisitTopLevelType(typeReferenceIndexer, RootModuleType);
yield return(RootModuleType);
foreach (var typeDef in GetAnonymousTypeDefinitions(context))
{
AddTopLevelType(names, typeDef);
VisitTopLevelType(typeReferenceIndexer, typeDef);
yield return(typeDef);
}
foreach (var typeDef in GetTopLevelTypeDefinitionsCore(context))
{
AddTopLevelType(names, typeDef);
VisitTopLevelType(typeReferenceIndexer, typeDef);
yield return(typeDef);
}
var privateImpl = PrivateImplClass;
if (privateImpl != null)
{
AddTopLevelType(names, privateImpl);
VisitTopLevelType(typeReferenceIndexer, privateImpl);
yield return(privateImpl);
}
if (EmbeddedTypesManagerOpt != null)
{
foreach (var embedded in EmbeddedTypesManagerOpt.GetTypes(context.Diagnostics, names))
{
AddTopLevelType(names, embedded);
yield return(embedded);
}
}
if (names != null)
{
Debug.Assert(_namesOfTopLevelTypes == null);
_namesOfTopLevelTypes = names;
}
}
Cci.INamespaceTypeDefinition Cci.ITypeReference.AsNamespaceTypeDefinition(EmitContext context)
{
return(this);
}
IEnumerable <Cci.TypeReferenceWithAttributes> Cci.ITypeDefinition.Interfaces(EmitContext context)
{
return(GetInterfaces(context));
}
Cci.ITypeDefinition Cci.ITypeReference.GetResolvedType(EmitContext context)
{
return(null);
}
Cci.IUnitReference Cci.INamespaceTypeReference.GetUnit(EmitContext context)
{
return(TypeManager.ModuleBeingBuilt);
}
Cci.IMethodDefinition Cci.IMethodReference.GetResolvedMethod(EmitContext context)
{
return(ResolvedMethodImpl(context));
}
internal static ITypeReference GetUninstantiatedGenericType(this ITypeReference typeReference, EmitContext context)
{
IGenericTypeInstanceReference genericTypeInstanceReference = typeReference.AsGenericTypeInstanceReference;
if (genericTypeInstanceReference != null)
{
return(genericTypeInstanceReference.GetGenericType(context));
}
ISpecializedNestedTypeReference specializedNestedType = typeReference.AsSpecializedNestedTypeReference;
if (specializedNestedType != null)
{
return(specializedNestedType.GetUnspecializedVersion(context));
}
return(typeReference);
}
IEnumerable <Cci.ITypeReference> Cci.IGenericMethodInstanceReference.GetGenericArguments(EmitContext context)
{
PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module;
Debug.Assert(((Cci.IMethodReference) this).AsGenericMethodInstanceReference != null);
foreach (var arg in this.TypeArguments)
{
yield return(moduleBeingBuilt.Translate(arg,
syntaxNodeOpt: context.SyntaxNodeOpt,
diagnostics: context.Diagnostics));
}
yield break;
}
Cci.IMethodBody Cci.IMethodDefinition.GetBody(EmitContext context)
{
CheckDefinitionInvariant();
return(((PEModuleBuilder)context.Module).GetMethodBody(this));
}
public override IEnumerable <Cci.IFileReference> GetFiles(EmitContext context) => SpecializedCollections.EmptyEnumerable <Cci.IFileReference>();
public override CType GetEvaluatedCType(EmitContext ec)
{
return(Left.GetEvaluatedCType(ec));
}
public virtual System.Reflection.MethodImplAttributes GetImplementationAttributes(EmitContext context)
{
CheckDefinitionInvariant();
return(this.ImplementationAttributes);
}
Cci.IDefinition Cci.IReference.AsDefinition(EmitContext context)
{
return(null);
}
public MetadataVisitor(EmitContext context)
{
this.Context = context;
}
protected abstract IEnumerable <Cci.TypeReferenceWithAttributes> GetInterfaces(EmitContext context);
Cci.ITypeReference Cci.ICustomModifier.GetModifier(EmitContext context)
{
return(((PEModuleBuilder)context.Module).Translate(this.Modifier, (CSharpSyntaxNode)context.SyntaxNodeOpt, context.Diagnostics));
}
IEnumerable <Cci.INestedTypeDefinition> Cci.ITypeDefinition.GetNestedTypes(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <Cci.INestedTypeDefinition>());
}
Cci.IMethodReference Cci.IGenericMethodInstanceReference.GetGenericMethod(EmitContext context)
{
return(_genericMethod);
}
IEnumerable <Cci.MethodImplementation> Cci.ITypeDefinition.GetExplicitImplementationOverrides(EmitContext context)
{
return(SpecializedCollections.EmptyEnumerable <Cci.MethodImplementation>());
}
IEnumerable <Cci.ITypeReference> Cci.IGenericMethodInstanceReference.GetGenericArguments(EmitContext context)
{
PEModuleBuilder moduleBeingBuilt = (PEModuleBuilder)context.Module;
foreach (var arg in UnderlyingMethod.TypeArgumentsWithAnnotations)
{
Debug.Assert(arg.CustomModifiers.IsEmpty);
yield return(moduleBeingBuilt.Translate(arg.Type, syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt, diagnostics: context.Diagnostics));
}
}
public DeletedMethodBody(DeletedMethodDefinition methodDef, EmitContext context)
{
_methodDef = methodDef;
_ilBytes = GetIL(context);
}
internal override IEnumerable <Cci.INamespaceTypeDefinition> GetTopLevelTypesCore(EmitContext context)
{
return(_changes.GetTopLevelTypes(context));
}
public sealed override Cci.ITypeReference GetPlatformType(Cci.PlatformType platformType, EmitContext context)
{
Debug.Assert((object)this == context.Module);
switch (platformType)
{
case Cci.PlatformType.SystemType:
return(GetSystemType((TSyntaxNode)context.SyntaxNodeOpt, context.Diagnostics));
default:
return(GetSpecialType((SpecialType)platformType, (TSyntaxNode)context.SyntaxNodeOpt, context.Diagnostics));
}
}
Cci.ITypeDefinition Cci.ITypeReference.AsTypeDefinition(EmitContext context)
{
return(null);
}
public MatchDefs(EmitContext sourceContext)
{
_sourceContext = sourceContext;
_matches = new ConcurrentDictionary <Cci.IDefinition, Cci.IDefinition>(ReferenceEqualityComparer.Instance);
}
Cci.IDefinition Cci.IReference.AsDefinition(EmitContext context)
{
return(ResolvedMethodImpl(context));
}