/// <summary>
/// Adds extension methods to <paramref name="res"/>.
/// </summary>
public static void AddExtensions(LanguageProperties language, ArrayList res, IClass callingClass, IReturnType resolvedType)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
if (res == null)
{
throw new ArgumentNullException("res");
}
if (callingClass == null)
{
throw new ArgumentNullException("callingClass");
}
if (resolvedType == null)
{
throw new ArgumentNullException("resolvedType");
}
bool supportsExtensionMethods = language.SupportsExtensionMethods;
bool supportsExtensionProperties = language.SupportsExtensionProperties;
if (supportsExtensionMethods || supportsExtensionProperties)
{
ArrayList list = new ArrayList();
IMethod dummyMethod = new DefaultMethod("dummy", VoidReturnType.Instance, ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, callingClass);
CtrlSpaceResolveHelper.AddContentsFromCalling(list, callingClass, dummyMethod);
CtrlSpaceResolveHelper.AddImportedNamespaceContents(list, callingClass.CompilationUnit, callingClass);
bool searchExtensionsInClasses = language.SearchExtensionsInClasses;
foreach (object o in list)
{
if (supportsExtensionMethods && o is IMethod || supportsExtensionProperties && o is IProperty)
{
TryAddExtension(language, res, o as IMethodOrProperty, resolvedType);
}
else if (searchExtensionsInClasses && o is IClass)
{
IClass c = o as IClass;
if (c.HasExtensionMethods)
{
if (supportsExtensionProperties)
{
foreach (IProperty p in c.Properties)
{
TryAddExtension(language, res, p, resolvedType);
}
}
if (supportsExtensionMethods)
{
foreach (IMethod m in c.Methods)
{
TryAddExtension(language, res, m, resolvedType);
}
}
}
}
}
}
}
void AddMethod(MethodDefinition method)
{
if (IsVisible(method.Attributes))
{
DefaultMethod m = new DefaultMethod(this, method.IsConstructor ? "#ctor" : method.Name);
if (method.GenericParameters.Count > 0)
{
foreach (GenericParameter g in method.GenericParameters)
{
m.TypeParameters.Add(new DefaultTypeParameter(m, g.Name, g.Position));
}
int i = 0;
foreach (GenericParameter g in method.GenericParameters)
{
AddConstraintsFromType(m.TypeParameters[i++], g);
}
}
m.ReturnType = CreateType(this.ProjectContent, m, method.ReturnType.ReturnType);
AddAttributes(CompilationUnit.ProjectContent, m.Attributes, method.CustomAttributes);
if (this.ClassType == ClassType.Interface)
{
m.Modifiers = ModifierEnum.Public | ModifierEnum.Abstract;
}
else
{
m.Modifiers = TranslateModifiers(method);
}
AddParameters(m, method.Parameters);
AddExplicitInterfaceImplementations(method.Overrides, m);
ReflectionLayer.ReflectionMethod.ApplySpecialsFromAttributes(m);
Methods.Add(m);
}
}
private IMethod ReadMethod()
{
DefaultMethod m = new DefaultMethod(_currentClass, ReadString());
_currentMethod = m;
ReadMember(m);
int count = _reader.ReadByte();
for (int i = 0; i < count; i++)
{
m.TypeParameters.Add(new DefaultTypeParameter(m, ReadString(), i));
}
if (count > 0)
{
foreach (ITypeParameter typeParameter in m.TypeParameters)
{
count = _reader.ReadInt32();
for (int i = 0; i < count; i++)
{
typeParameter.Constraints.Add(ReadType());
}
}
}
else
{
m.TypeParameters = DefaultTypeParameter.EmptyTypeParameterList;
}
m.ReturnType = ReadType();
m.IsExtensionMethod = _reader.ReadBoolean();
ReadParameters(m);
_currentMethod = null;
return(m);
}
private void ReadParameters(DefaultMethod m)
{
int count = _reader.ReadUInt16();
if (count > 0)
{
ReadParameters(m.Parameters, count);
}
else
{
m.Parameters = DefaultParameter.EmptyParameterList;
}
}
public override IMember Clone()
{
DefaultMethod p = new DefaultMethod(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType);
p.parameters = DefaultParameter.Clone(this.Parameters);
p.typeParameters = this.typeParameters;
p.documentationTag = DocumentationTag;
p.isExtensionMethod = this.isExtensionMethod;
foreach (ExplicitInterfaceImplementation eii in InterfaceImplementations)
{
p.InterfaceImplementations.Add(eii.Clone());
}
return(p);
}
internal static void AddDefaultDelegateMethod(DefaultClass c, IReturnType returnType, IList <IParameter> parameters)
{
ModifierEnum modifiers = ModifierEnum.Public | ModifierEnum.Synthetic;
DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters)
{
invokeMethod.Parameters.Add(par);
}
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, modifiers, c.Region, DomRegion.Empty, c);
foreach (IParameter par in parameters)
{
invokeMethod.Parameters.Add(par);
}
invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty));
invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty));
c.Methods.Add(invokeMethod);
invokeMethod = new DefaultMethod("EndInvoke", returnType, modifiers, c.Region, DomRegion.Empty, c);
invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty));
c.Methods.Add(invokeMethod);
}
