public ExternalGenericParameter(TypeSystemServices tss, Type type) : base(tss, type) { if (type.DeclaringMethod != null) { _declaringMethod = (IMethod)tss.Map(type.DeclaringMethod); } }
Method CreateBeginInvokeExtension(ICallableType anonymousType, Method beginInvoke, out MethodInvocationExpression mie) { InternalMethod beginInvokeEntity = (InternalMethod)beginInvoke.Entity; Method extension = CodeBuilder.CreateMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)), TypeMemberModifiers.Public | TypeMemberModifiers.Static); extension.Attributes.Add(CodeBuilder.CreateAttribute(Types.ExtensionAttribute)); ParameterDeclaration self = CodeBuilder.CreateParameterDeclaration(0, "self", beginInvokeEntity.DeclaringType); extension.Parameters.Add(self); CodeBuilder.DeclareParameters(extension, 1, anonymousType.GetSignature().Parameters); mie = CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateReference(self), beginInvokeEntity); ParameterDeclarationCollection parameters = extension.Parameters; for (int i = 1; i < parameters.Count; ++i) { mie.Arguments.Add(CodeBuilder.CreateReference(parameters[i])); } extension.Body.Add(new ReturnStatement(mie)); return(extension); }
public IEntity GetDefaultMember() { IType defaultMemberAttribute = _typeSystemServices.Map(typeof(DefaultMemberAttribute)); foreach (Attribute attribute in _typeDefinition.Attributes) { IConstructor tag = TypeSystemServices.GetEntity(attribute) as IConstructor; if (null != tag) { if (defaultMemberAttribute == tag.DeclaringType) { StringLiteralExpression memberName = attribute.Arguments[0] as StringLiteralExpression; if (null != memberName) { List buffer = new List(); Resolve(buffer, memberName.Value, EntityType.Any); return(NameResolutionService.GetEntityFromList(buffer)); } } } } if (null != BaseType) { return(BaseType.GetDefaultMember()); } return(null); }
public void Add(Type type) { Assembly assembly = type.Assembly; List types = (List)_assemblies[assembly]; if (null == types) { types = new List(); _assemblies[assembly] = types; } types.Add(type); if (_typeSystemServices.IsModule(type)) { _externalModules.Add(_typeSystemServices.Map(type)); } }
public virtual IParameter[] GetParameters() { if (null == _parameters) { _parameters = _typeSystemServices.Map(_mi.GetParameters()); } return(_parameters); }
public IParameter[] GetParameters() { if (null == _parameters) { _parameters = _typeSystemServices.Map(_property.Parameters); } return(_parameters); }
Method CreateBeginInvokeMethod(ICallableType anonymousType) { Method method = CodeBuilder.CreateRuntimeMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)), anonymousType.GetSignature().Parameters, false); int delta = method.Parameters.Count; method.Parameters.Add( CodeBuilder.CreateParameterDeclaration(delta + 1, "callback", TypeSystemServices.Map(typeof(AsyncCallback)))); method.Parameters.Add( CodeBuilder.CreateParameterDeclaration(delta + 1, "asyncState", TypeSystemServices.ObjectType)); return(method); }
public IEntity GetDefaultMember() { IType defaultMemberAttribute = _typeSystemServices.Map(Types.DefaultMemberAttribute); foreach (Attribute attribute in _typeDefinition.Attributes) { IConstructor tag = TypeSystemServices.GetEntity(attribute) as IConstructor; if (null != tag) { if (defaultMemberAttribute == tag.DeclaringType) { StringLiteralExpression memberName = attribute.Arguments[0] as StringLiteralExpression; if (null != memberName) { List buffer = new List(); Resolve(buffer, memberName.Value, EntityType.Any); return(NameResolutionService.GetEntityFromList(buffer)); } } } } if (_typeDefinition.BaseTypes.Count > 0) { List buffer = new List(); foreach (TypeReference baseType in _typeDefinition.BaseTypes) { IType tag = TypeSystemServices.GetType(baseType); IEntity defaultMember = tag.GetDefaultMember(); if (defaultMember != null) { if (tag.IsInterface) { buffer.AddUnique(defaultMember); } else //non-interface base class trumps interfaces { return(defaultMember); } } } return(NameResolutionService.GetEntityFromList(buffer)); } return(null); }
private IMember FindByMetadataToken(IMember source, ExternalType targetType) { // HACK: since the API doesn't provide a way to correlate members on a generic type // with the mapped members on a constructed type, we have to rely on them sharing the same // metadata token. MemberInfo sourceMemberInfo = ((IExternalEntity)source).MemberInfo; MemberFilter filter = delegate(MemberInfo candidate, object metadataToken) { return(candidate.MetadataToken.Equals(metadataToken)); }; BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly; bindingFlags |= (source.IsStatic ? BindingFlags.Static : BindingFlags.Instance); MemberInfo[] mappedMemberInfos = targetType.ActualType.FindMembers( sourceMemberInfo.MemberType, bindingFlags, filter, sourceMemberInfo.MetadataToken); return((IMember)TypeSystemServices.Map(mappedMemberInfos[0])); }
public Method CreateEndInvokeMethod(ICallableType anonymousType) { CallableSignature signature = anonymousType.GetSignature(); Method method = CodeBuilder.CreateRuntimeMethod("EndInvoke", signature.ReturnType); int delta = 1; foreach (IParameter p in signature.Parameters) { if (p.IsByRef) { method.Parameters.Add( CodeBuilder.CreateParameterDeclaration(++delta, p.Name, p.Type, true)); } } delta = method.Parameters.Count; method.Parameters.Add( CodeBuilder.CreateParameterDeclaration(delta + 1, "result", TypeSystemServices.Map(typeof(IAsyncResult)))); return(method); }
bool IsAttributeDefined(System.Type attributeType) { IType entity = _typeSystemServices.Map(attributeType); return(MetadataUtil.IsAttributeDefined(_method, entity)); }
Method CreateBeginInvokeCallbackOnlyExtension(ICallableType anonymousType, Method beginInvoke) { MethodInvocationExpression mie; Method overload = CreateBeginInvokeExtension(anonymousType, beginInvoke, out mie); ParameterDeclaration callback = CodeBuilder.CreateParameterDeclaration(overload.Parameters.Count, "callback", TypeSystemServices.Map(typeof(AsyncCallback))); overload.Parameters.Add(callback); mie.Arguments.Add(CodeBuilder.CreateReference(callback)); mie.Arguments.Add(CodeBuilder.CreateNullLiteral()); return(overload); }
public virtual IType GetElementType() { return(_typeSystemServices.Map(_type.GetElementType())); }
public Attribute CreateAttribute(System.Type type) { return(CreateAttribute(TypeSystemServices.Map(type))); }
public ReferenceExpression CreateReference(LexicalInfo li, System.Type type) { return(CreateReference(li, TypeSystemServices.Map(type))); }
public TypeReference CreateTypeReference(LexicalInfo li, Type type) { return(CreateTypeReference(li, TypeSystemServices.Map(type))); }
public TypeReference CreateTypeReference(Type type) { return(CreateTypeReference(TypeSystemServices.Map(type))); }
public MethodInvocationExpression CreateMethodInvocation(MethodInfo staticMethod, Expression arg0, Expression arg1) { return(CreateMethodInvocation(TypeSystemServices.Map(staticMethod), arg0, arg1)); }
public Expression CreateTypeofExpression(System.Type type) { return(CreateTypeofExpression(_tss.Map(type))); }
protected IType Map(Type type) { return(_typeSystemServices.Map(type)); }
internal ExternalCallableType(TypeSystemServices typeSystemServices, Type type) : base(typeSystemServices, type) { _invoke = typeSystemServices.Map(type.GetMethod("Invoke")); }
public Expression CreateTypeofExpression(System.Type type) { return(CreateTypeofExpression(TypeSystemServices.Map(type))); }
public Attribute CreateAttribute(System.Type type) { return(CreateAttribute(_tss.Map(type))); }
public MethodInvocationExpression CreateMethodInvocation(Expression target, MethodInfo method) { return(CreateMethodInvocation(target, TypeSystemServices.Map(method))); }