public override bool IsAccessible(AccessLevelMask accessLevelMask)
{
foreach (var method in methods)
{
if (method.IsAccessible(accessLevelMask))
{
return(true);
}
}
return(false);
}
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
base.GetMembersCompletionData(data, flags, mask, assembly);
if (completionsFromBase)
{
return;
}
completionsFromBase = true;
var baseType = BaseType();
var interfaces = Interfaces();
if (flags != BindingFlags.Static && (kind == SymbolKind.Interface || kind == SymbolKind.TypeParameter))
{
foreach (var i in interfaces)
{
i.Definition.GetMembersCompletionData(data, flags, mask & ~AccessLevelMask.Private, assembly);
}
}
if (baseType != null && (kind != SymbolKind.Enum || flags != BindingFlags.Static) &&
(baseType.kind != SymbolKind.Interface || kind == SymbolKind.Interface || kind == SymbolKind.TypeParameter))
{
baseType.GetMembersCompletionData(data, flags, mask & ~AccessLevelMask.Private, assembly);
}
completionsFromBase = false;
}
public void GetExtensionMethodsCompletionData(TypeDefinitionBase targetType, Dictionary <string, SymbolDefinition> data, AccessLevelMask accessLevelMask)
{
// Debug.Log("Extensions for " + targetType.GetTooltipText());
foreach (var t in members)
{
if (t.kind == SymbolKind.Class && t.IsStatic && t.NumTypeParameters == 0 &&
(t as TypeDefinitionBase).numExtensionMethods > 0 && t.IsAccessible(accessLevelMask))
{
var classMembers = t.members;
foreach (var cm in classMembers)
{
if (cm.kind == SymbolKind.MethodGroup)
{
var mg = cm as SD_MethodGroup;
if (mg == null)
{
continue;
}
if (data.ContainsKey(mg.name))
{
continue;
}
foreach (var m in mg.methods)
{
if (m.kind != SymbolKind.Method)
{
continue;
}
if (!m.IsExtensionMethod)
{
continue;
}
if (!m.IsAccessible(accessLevelMask))
{
continue;
}
var parameters = m.GetParameters();
if (parameters == null || parameters.Count == 0)
{
continue;
}
if (!targetType.CanConvertTo(parameters[0].TypeOf() as TypeDefinitionBase))
{
continue;
}
data.Add(m.name, m);
break;
}
}
}
}
}
}
public void GetTypesOnlyCompletionData(Dictionary <string, SymbolDefinition> data, AccessLevelMask mask, SD_Assembly assembly)
{
if ((mask & AccessLevelMask.Public) != 0)
{
if (assembly.InternalsVisibleIn(this.Assembly))
{
mask |= AccessLevelMask.Internal;
}
else
{
mask &= ~AccessLevelMask.Internal;
}
}
foreach (var m in members)
{
if (m.kind == SymbolKind.Namespace)
{
continue;
}
if (m.kind != SymbolKind.MethodGroup)
{
if (m.IsAccessible(mask) && !data.ContainsKey(m.ReflectionName))
{
data.Add(m.ReflectionName, m);
}
}
}
var assemblyDefinition = Assembly;
if (assemblyDefinition != null)
{
assemblyDefinition.GetTypesOnlyCompletionDataFromReferencedAssemblies(data, this);
}
}
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
base.GetMembersCompletionData(data, flags, mask, assembly);
var assemblyDefinition = assembly ?? parentSymbol;
while (assemblyDefinition != null && !(assemblyDefinition is SD_Assembly))
{
assemblyDefinition = assemblyDefinition.parentSymbol;
}
((SD_Assembly)assemblyDefinition).GetMembersCompletionDataFromReferencedAssemblies(data, this);
}
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
var symbolType = TypeOf();
if (symbolType != null)
{
symbolType.GetMembersCompletionData(data, BindingFlags.Instance, mask, assembly);
}
}
//private Dictionary<BindingFlags, Dictionary<string, SymbolDefinition>> cachedMemberCompletions;
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
if (!allPublicMembersReflected)
{
if (!allNonPublicMembersReflected && ((mask & AccessLevelMask.NonPublic) != 0 || (flags & BindingFlags.NonPublic) != 0))
{
ReflectAllMembers(BindingFlags.Public | BindingFlags.NonPublic);
}
else
{
ReflectAllMembers(BindingFlags.Public);
}
}
else if (!allNonPublicMembersReflected && ((mask & AccessLevelMask.NonPublic) != 0 || (flags & BindingFlags.NonPublic) != 0))
{
ReflectAllMembers(BindingFlags.NonPublic);
}
base.GetMembersCompletionData(data, flags, mask, assembly);
}
private static void GetMemberCompletions(SymbolDefinition targetDef, SyntaxTreeNode_Base parseTreeNode,
SD_Assembly assemblyDefinition, Dictionary <string, SymbolDefinition> d, bool includeExtensionMethods)
{
if (targetDef != null)
{
var typeOf = targetDef.TypeOf();
var flags = BindingFlags.Instance | BindingFlags.Static;
switch (targetDef.kind)
{
case SymbolKind.None:
case SymbolKind.Error:
break;
case SymbolKind.Namespace:
case SymbolKind.Interface:
case SymbolKind.Struct:
case SymbolKind.Class:
case SymbolKind.TypeParameter:
case SymbolKind.Delegate:
flags = BindingFlags.Static;
break;
case SymbolKind.Enum:
flags = BindingFlags.Static;
break;
case SymbolKind.Field:
case SymbolKind.ConstantField:
case SymbolKind.LocalConstant:
case SymbolKind.Property:
case SymbolKind.Event:
case SymbolKind.Indexer:
case SymbolKind.Method:
case SymbolKind.MethodGroup:
case SymbolKind.Constructor:
case SymbolKind.Destructor:
case SymbolKind.Operator:
case SymbolKind.Accessor:
case SymbolKind.Parameter:
case SymbolKind.CatchParameter:
case SymbolKind.Variable:
case SymbolKind.ForEachVariable:
case SymbolKind.FromClauseVariable:
case SymbolKind.EnumMember:
flags = BindingFlags.Instance;
break;
case SymbolKind.BaseTypesList:
case SymbolKind.TypeParameterConstraintList:
flags = BindingFlags.Static;
break;
case SymbolKind.Instance:
flags = BindingFlags.Instance;
break;
case SymbolKind.Null:
return;
default:
throw new ArgumentOutOfRangeException();
}
//targetDef.kind = targetDef is TypeDefinitionBase && targetDef.kind != SymbolKind.Enum ? BindingFlags.Static : targetDef is InstanceDefinition ? BindingFlags.Instance : 0;
TypeDefinitionBase contextType = null;
for (var n = parseTreeNode as SyntaxTreeNode_Rule ?? parseTreeNode.Parent; n != null; n = n.Parent)
{
var s = n.scope as Scope_SymbolDeclaration;
if (s != null)
{
contextType = s.declaration.definition as TypeDefinitionBase;
if (contextType != null)
{
break;
}
}
}
AccessLevelMask mask =
typeOf == contextType || typeOf.IsSameOrParentOf(contextType) ? AccessLevelMask.Private | AccessLevelMask.Protected | AccessLevelMask.Internal | AccessLevelMask.Public :
contextType != null && contextType.DerivesFrom(typeOf as TypeDefinitionBase) ? AccessLevelMask.Protected | AccessLevelMask.Internal | AccessLevelMask.Public :
AccessLevelMask.Internal | AccessLevelMask.Public;
if (typeOf.Assembly == null || !typeOf.Assembly.InternalsVisibleIn(assemblyDefinition))
{
mask &= ~AccessLevelMask.Internal;
}
typeOf.GetMembersCompletionData(d, flags, mask, assemblyDefinition);
if (includeExtensionMethods && flags == BindingFlags.Instance &&
(typeOf.kind == SymbolKind.Class || typeOf.kind == SymbolKind.Struct || typeOf.kind == SymbolKind.Interface || typeOf.kind == SymbolKind.Enum))
{
var enclosingScopeNode = parseTreeNode as SyntaxTreeNode_Rule ?? parseTreeNode.Parent;
while (enclosingScopeNode != null && enclosingScopeNode.scope == null)
{
enclosingScopeNode = enclosingScopeNode.Parent;
}
var enclosingScope = enclosingScopeNode != null ? enclosingScopeNode.scope : null;
if (enclosingScope != null)
{
enclosingScope.GetExtensionMethodsCompletionData(typeOf as TypeDefinitionBase, d);
}
}
}
}
//public override TypeDefinitionBase SubstituteTypeParameters(SymbolDefinition context)
//{
// if (typeParameters == null)
// return base.SubstituteTypeParameters(context);
// var constructType = false;
// var typeArguments = new SymbolReference[typeParameters.Count];
// for (var i = 0; i < typeArguments.Length; ++i)
// {
// typeArguments[i] = new SymbolReference(typeParameters[i]);
// var original = typeParameters[i];
// if (original == null)
// continue;
// var substitute = original.SubstituteTypeParameters(context);
// if (substitute != original)
// {
// typeArguments[i] = new SymbolReference(substitute);
// constructType = true;
// }
// }
// if (!constructType)
// return this;
// return ConstructType(typeArguments);
//}
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
foreach (var parameter in GetParameters())
{
var parameterName = parameter.GetName();
if (!data.ContainsKey(parameterName))
{
data.Add(parameterName, parameter);
}
}
if ((flags & (BindingFlags.Instance | BindingFlags.Static)) != BindingFlags.Instance)
{
if (typeParameters != null)
{
foreach (var parameter in typeParameters)
{
var parameterName = parameter.name;
if (!data.ContainsKey(parameterName))
{
data.Add(parameterName, parameter);
}
}
}
}
// ReturnType().GetMembersCompletionData(data, flags, mask, assembly);
}
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
}
public override void GetMembersCompletionData(Dictionary <string, SymbolDefinition> data, BindingFlags flags, AccessLevelMask mask, SD_Assembly assembly)
{
var dataFromDefinition = new Dictionary <string, SymbolDefinition>();
genericTypeDefinition.GetMembersCompletionData(dataFromDefinition, flags, mask, assembly);
foreach (var entry in dataFromDefinition)
{
if (!data.ContainsKey(entry.Key))
{
var member = GetConstructedMember(entry.Value);
data.Add(entry.Key, member);
}
}
}
