private void AddDelegates(ITypeShape typeShape)
{
var typeMembers = _typeElement.GetMembers();
var delegateTypeNames =
typeMembers.OfType <IDelegate>()
.Select(d => d.GetName <IDelegateTypeName>());
typeShape.Delegates.AddAll(delegateTypeNames);
}
public static IEnumerable <IMethod> GetAllMethods([NotNull] this ITypeElement typeElement)
{
if (typeElement == null)
{
throw new ArgumentNullException("typeElement");
}
return(typeElement.GetMembers().OfType <IMethod>());
}
public static void NavigateToFirstMember([NotNull] this ITypeElement typeElement)
{
if (typeElement == null)
{
throw new ArgumentNullException("typeElement");
}
var member = typeElement.GetMembers().FirstOrDefault();
member.Navigate(true);
}
public override void Populate(CSharpGeneratorContext context)
{
// use context.ProvidedElements.AddRange to add new
// generator elements (e.g., GeneratorDeclaredElement<T>)
IClassLikeDeclaration typeDeclaration = context.ClassDeclaration;
ITypeElement typeElement = typeDeclaration.DeclaredElement;
ListHandler.Initialize(context);
MethodGeneratorBase.Initialize(context);
GetBytesMethodGenerator.Initialize(context);
SetBytesMethodGenerator.Initialize(context);
if (typeElement is IClass || typeElement is IStruct)
{
var ctx = new TypeHandlingContext(context);
foreach (ITypeMember member in typeElement.GetMembers())
{
ITypeOwner owner = null;
var field = member as IField;
if (field != null)
{
if (field.GetAccessRights() != AccessRights.PRIVATE &&
!field.IsConstant &&
!field.IsReadonly &&
!field.IsStatic)
{
owner = field;
}
}
var property = member as IProperty;
if (property != null)
{
if (property.IsReadable &&
property.IsWritable &&
!property.IsStatic)
{
owner = property;
}
}
if (owner != null)
{
ctx.Resolve(owner);
if (TypeHandlers.All.Any(h => h.CanHandle(ctx)))
{
context.ProvidedElements.Add(new GeneratorDeclaredElement <ITypeOwner>(owner));
}
}
}
}
}
private void ProcessClass(ITypeElement element, ICollection <HandlerCompletionItem> handlers)
{
var nestedClasses = element.GetMembers().OfType <IClass>();
foreach (var @class in nestedClasses)
{
ProcessClass(@class, handlers);
}
var methods = element.Methods;
foreach (var method in methods)
{
GetHandlers(method, handlers);
}
}
private void AppendTests(CSUnitTestFixtureElement fixtureElement, IEnumerable <IDeclaredType> types, ref int order)
{
foreach (IDeclaredType type in types)
{
ITypeElement typeElement = type.GetTypeElement();
if (typeElement == null)
{
continue;
}
foreach (ITypeMember member in typeElement.GetMembers())
{
if (IsTestMethod(member))
{
new CSUnitTestElement(myProvider, fixtureElement, myProject, typeElement.CLRName, member.ShortName, order++);
}
}
AppendTests(fixtureElement, type.GetSuperTypes(), ref order);
}
}
private void SetClassAndMembersUsed(IClassDeclaration classDeclaration)
{
ITypeElement typeElement = classDeclaration.DeclaredElement;
if (typeElement == null || (typeElement is IClass == false))
{
return;
}
foreach (ITypeMember typeMember in typeElement.GetMembers())
{
var method = typeMember as IMethod;
if (method != null)
{
usages.SetElementState(method, UsageState.ALL_MASK);
}
}
usages.SetElementState(typeElement, UsageState.ALL_MASK);
}
private ITypeMember[] ResolveMember(ITypeElement resolvedType, IInvocationExpression invocation)
{
var nameArgument = NameArgument(invocation);
var bindingFlags = ArgumentConstantValue <BindingFlags>(BindingFlagsArgument(invocation));
bool ignoreCase = bindingFlags.HasValue && (bindingFlags.Value & BindingFlags.IgnoreCase) != 0;
if (nameArgument.IsConstantValue())
{
string memberName = (string)nameArgument.ConstantValue.Value;
var members = resolvedType.GetMembers()
.Where(m => string.Compare(m.ShortName, memberName, ignoreCase) == 0);
if (ExpectedMemberType != null)
{
members = members.Where(m => m.GetElementType() == ExpectedMemberType);
}
return(members.ToArray());
}
return(new ITypeMember[0]);
}
private static IList <ITypeMember> GetStaticColorProperties(ITypeElement unityColorType)
{
var colorProperties = new LocalList <ITypeMember>();
foreach (var typeMember in unityColorType.GetMembers())
{
if (!typeMember.IsStatic)
{
continue;
}
var typeOwner = typeMember as ITypeOwner;
if (typeOwner is IProperty || typeOwner is IField)
{
var declaredType = typeOwner.Type as IDeclaredType;
if (declaredType != null && unityColorType.Equals(declaredType.GetTypeElement()))
{
colorProperties.Add(typeMember);
}
}
}
return(colorProperties.ResultingList());
}
private static IList<ITypeMember> GetStaticColorProperties(ITypeElement unityColorType)
{
var colorProperties = new LocalList<ITypeMember>();
foreach (var typeMember in unityColorType.GetMembers())
{
if (!typeMember.IsStatic) continue;
var typeOwner = typeMember as ITypeOwner;
if (typeOwner is IProperty || typeOwner is IField)
{
var declaredType = typeOwner.Type as IDeclaredType;
if (declaredType != null && unityColorType.Equals(declaredType.GetTypeElement()))
{
colorProperties.Add(typeMember);
}
}
}
return colorProperties.ResultingList();
}
