public static SD_Assembly FromAssembly(Assembly assembly)
{
SD_Assembly definition;
if (!allAssemblies.TryGetValue(assembly, out definition))
{
definition = new SD_Assembly(assembly);
allAssemblies[assembly] = definition;
}
return(definition);
}
public bool InternalsVisibleIn(SD_Assembly referencingAssembly)
{
if (referencingAssembly == this)
{
return(true);
}
//TODO: Check are internals visible
return(false);
}
public void ListOverrideCandidates(List <MethodDefinition> methods, SD_Assembly context)
{
if (completionsFromBase)
{
return;
}
completionsFromBase = true;
var baseType = BaseType();
if (baseType != null && (baseType.kind == SymbolKind.Class || baseType.kind == SymbolKind.Struct))
{
baseType.ListOverrideCandidates(methods, context);
}
completionsFromBase = false;
var accessLevelMask = AccessLevelMask.Public | AccessLevelMask.Protected;
if (Assembly.InternalsVisibleIn(context))
{
accessLevelMask |= AccessLevelMask.Internal;
}
for (var i = members.Count; i-- > 0;)
{
var member = members[i];
if (member.kind == SymbolKind.MethodGroup)
{
var asMethodGroup = member as SD_MethodGroup;
if (asMethodGroup != null)
{
foreach (var method in asMethodGroup.methods)
{
if ((method.IsVirtual || method.IsAbstract) && method.IsAccessible(accessLevelMask))
{
methods.Add(method);
}
}
}
}
}
}
protected void InitTypes()
{
m_setTypes = new HashSet <string>();
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
try
{
if (assembly is System.Reflection.Emit.AssemblyBuilder)
{
continue;
}
var takeAllTypes = SD_Assembly.IsScriptAssemblyName(assembly.GetName().Name);
var assemblyTypes = takeAllTypes ? assembly.GetTypes() : assembly.GetExportedTypes();
foreach (var type in assemblyTypes)
{
var name = type.Name;
var index = name.IndexOf('`');
if (index >= 0)
{
name = name.Remove(index);
}
m_setTypes.Add(name);
if (type.IsSubclassOf(typeof(Attribute)) && name.EndsWith("Attribute", StringComparison.Ordinal))
{
m_setTypes.Add(type.Name.Substring(0, type.Name.Length - "Attribute".Length));
}
}
}
catch (ReflectionTypeLoadException)
{
Debug.LogWarning("Error reading types from assembly " + assembly.FullName);
}
}
}
static void Test()
{
var s =
#region A
@"using System.IO;";
#endregion
var k1 = s.Replace("\r\n", "\n");
var e1 = new List <string>(k1.Split('\n'));
var fls = LRHelper_UnityShell.Lex(e1);
//foreach(var line in fls)
//{
// string s = "";
// foreach(var token in line.tokens)
// {
// s += token.ToString();
// }
// Debug.LogError(s);
//}
var tree = LRHelper_UnityShell.Parse(fls, SD_Assembly.GetCompilationUnitScope(SD_Assembly.UnityAssembly.CSharp, "aa"));
//var tree = LRHelper_CSharp.Parse(fls, SD_Assembly.GetCompilationUnitScope(path));
LRHelper_UnityShell.SysmbolResolve(fls);
Debug.LogError(tree);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (definition.name != "get")
{
data["value"] = Value;
}
definition.parentSymbol.GetCompletionData(data, fromInstance, assembly);
base.GetCompletionData(data, fromInstance, assembly);
}
public virtual void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (parentScope != null)
{
parentScope.GetCompletionData(data, fromInstance, assembly);
}
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
var attributeTypeLeaf = parseTreeNode.Parent.Parent.NodeAt(0).GetLastLeaf();
if (attributeTypeLeaf != null)
{
var attributeType = attributeTypeLeaf.ResolvedSymbol as TypeDefinitionBase;
if (attributeType != null)
{
var tempData = new Dictionary <string, SymbolDefinition>();
attributeType.GetMembersCompletionData(tempData, BindingFlags.Instance, AccessLevelMask.Public | AccessLevelMask.Internal, assembly);
foreach (var kv in tempData)
{
var symbolKind = kv.Value.kind;
if (symbolKind == SymbolKind.Field || symbolKind == SymbolKind.Property)
{
if (!data.ContainsKey(kv.Key))
{
data[kv.Key] = kv.Value;
}
}
}
}
}
base.GetCompletionData(data, fromInstance, assembly);
}
public static Scope_CompilationUnit GetCompilationUnitScope(SD_Assembly assembly, string sName, bool forceCreateNew = false)
{
if (assembly == null)
{
return(null);
}
if (assembly.compilationUnits == null)
{
assembly.compilationUnits = new Dictionary <string, Scope_CompilationUnit>();
}
Scope_CompilationUnit scope;
if (!assembly.compilationUnits.TryGetValue(sName, out scope) || forceCreateNew)
{
if (forceCreateNew)
{
if (scope != null && scope.typeDeclarations != null)
{
var newResolverVersion = false;
var scopeTypes = scope.typeDeclarations;
for (var i = scopeTypes.Count; i-- > 0;)
{
var typeDeclaration = scopeTypes[i];
scope.RemoveDeclaration(typeDeclaration);
newResolverVersion = true;
}
if (newResolverVersion)
{
++LR_SyntaxTree.resolverVersion;
if (LR_SyntaxTree.resolverVersion == 0)
{
++LR_SyntaxTree.resolverVersion;
}
}
}
assembly.compilationUnits.Remove(sName);
}
scope = new Scope_CompilationUnit
{
assembly = assembly,
path = sName,
};
assembly.compilationUnits[sName] = scope;
//var cuDefinition = new CompilationUnitDefinition
//{
// kind = SymbolKind.None,
// parentSymbol = assembly,
//};
scope.declaration = new Declaration_Namespace
{
kind = SymbolKind.Namespace,
definition = assembly.GlobalNamespace,
};
scope.definition = assembly.GlobalNamespace;
}
return(scope);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (definition != null)
{
definition.GetCompletionData(data, fromInstance, assembly);
}
Scope_Base scope = this;
while (fromInstance && scope != null)
{
var asBodyScope = scope as Scope_Body;
if (asBodyScope != null)
{
var symbol = asBodyScope.definition;
if (symbol != null && symbol.kind != SymbolKind.LambdaExpression)
{
if (!symbol.IsInstanceMember)
{
fromInstance = false;
}
break;
}
}
scope = scope.parentScope;
}
base.GetCompletionData(data, fromInstance, assembly);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (parameters != null)
{
for (var i = parameters.Count; i-- > 0;)
{
var p = parameters[i];
if (!data.ContainsKey(p.name))
{
data.Add(p.name, p);
}
}
}
}
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);
}
}
}
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);
}
}
//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 GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
assembly = GetAssembly();
definition.GetMembersCompletionData(data, BindingFlags.NonPublic, AccessLevelMask.Any, assembly);
foreach (var ta in declaration.typeAliases)
{
if (!data.ContainsKey(ta.name))
{
data.Add(ta.name, ta.type.Definition);
}
}
foreach (var i in declaration.importedNamespaces)
{
var nsDef = i.Definition as SD_NameSpace;
if (nsDef != null)
{
nsDef.GetTypesOnlyCompletionData(data, AccessLevelMask.Any, assembly);
}
}
var parentScopeDef = parentScope != null ? ((Scope_Namespace)parentScope).definition : null;
for (var nsDef = definition.parentSymbol;
nsDef != null && nsDef != parentScopeDef;
nsDef = nsDef.parentSymbol as SD_NameSpace)
{
nsDef.GetCompletionData(data, fromInstance, assembly);
}
base.GetCompletionData(data, false, assembly);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
GetMembersCompletionData(data, fromInstance ? 0 : BindingFlags.Static, AccessLevelMask.Any, assembly);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (declaration != null && declaration.definition != null)
{
var typeParameters = declaration.definition.GetTypeParameters();
if (typeParameters != null)
{
for (var i = typeParameters.Count; i-- > 0;)
{
var tp = typeParameters[i];
if (!data.ContainsKey(tp.name))
{
data.Add(tp.name, tp);
}
}
}
}
base.GetCompletionData(data, fromInstance, assembly);
}
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 static void GetCompletions_Profiled(IdentifierCompletionsType completionTypes, ParseTree.BaseNode parseTreeNode, HashSet <SymbolDefinition> completionSymbols, string assetPath)
{
#endif
try
{
var d = new Dictionary <string, SymbolDefinition>();
var assemblyDefinition = SD_Assembly.FromAssetPath(assetPath);
if ((completionTypes & IdentifierCompletionsType.MemberName) != 0)
{
SyntaxTreeNode_Base targetNode = null;
var node = parseTreeNode.Parent;
if (node.RuleName != "objectOrCollectionInitializer")
{
if (node.RuleName != "objectInitializer")
{
if (node.RuleName == "memberInitializerList")
{
node = node.Parent; // objectInitializer
}
}
node = node.Parent; // objectOrCollectionInitializer
}
node = node.Parent;
if (node.RuleName == "objectCreationExpression")
{
targetNode = node.Parent;
}
else // node is memberInitializer
{
targetNode = node.LeafAt(0);
}
var targetDef = targetNode != null?SymbolDefinition.ResolveNode(targetNode) : null;
if (targetDef != null)
{
GetMemberCompletions(targetDef, parseTreeNode, assemblyDefinition, d, false);
var filteredData = new Dictionary <string, SymbolDefinition>();
foreach (var kv in d)
{
var symbol = kv.Value;
if (symbol.kind == SymbolKind.Field && (symbol.modifiers & Modifiers.ReadOnly) == 0 ||
symbol.kind == SymbolKind.Property && symbol.FindName("set", 0, false) != null)
{
filteredData[kv.Key] = symbol;
}
}
d = filteredData;
}
var targetType = targetDef != null?targetDef.TypeOf() as TypeDefinitionBase : null;
if (targetType == null || !targetType.DerivesFrom(SymbolDefinition.builtInTypes_IEnumerable))
{
completionSymbols.Clear();
completionSymbols.UnionWith(d.Values);
return;
}
}
if ((completionTypes & IdentifierCompletionsType.Member) != 0)
{
var target = parseTreeNode.FindPreviousNode();
if (target != null)
{
var targetAsNode = target as SyntaxTreeNode_Rule;
if (targetAsNode != null && targetAsNode.RuleName == "primaryExpressionPart")
{
var node0 = targetAsNode.NodeAt(0);
if (node0 != null && node0.RuleName == "arguments")
{
target = target.FindPreviousNode();
targetAsNode = target as SyntaxTreeNode_Rule;
}
}
//Debug.Log(targetAsNode ?? target.parent);
ResolveNode(targetAsNode ?? target.Parent);
var targetDef = GetResolvedSymbol(targetAsNode ?? target.Parent);
GetMemberCompletions(targetDef, parseTreeNode, assemblyDefinition, d, true);
}
}
else if (parseTreeNode == null)
{
#if SI3_WARNINGS
Debug.LogWarning(completionTypes);
#endif
}
else
{
Scope_Base.completionNode = parseTreeNode;
Scope_Base.completionAssetPath = assetPath;
if (parseTreeNode.IsLit("=>"))
{
parseTreeNode = parseTreeNode.Parent.NodeAt(parseTreeNode.m_iChildIndex + 1) ?? parseTreeNode;
}
if (parseTreeNode.IsLit("]") && parseTreeNode.Parent.RuleName == "attributes")
{
parseTreeNode = parseTreeNode.Parent.Parent.NodeAt(parseTreeNode.Parent.m_iChildIndex + 1);
}
var enclosingScopeNode = parseTreeNode as SyntaxTreeNode_Rule ?? parseTreeNode.Parent;
if (enclosingScopeNode != null && (enclosingScopeNode.scope is Scope_SymbolDeclaration) &&
(parseTreeNode.IsLit(";") || parseTreeNode.IsLit("}")) &&
enclosingScopeNode.GetLastLeaf() == parseTreeNode)
{
enclosingScopeNode = enclosingScopeNode.Parent;
}
while (enclosingScopeNode != null && enclosingScopeNode.scope == null)
{
enclosingScopeNode = enclosingScopeNode.Parent;
}
if (enclosingScopeNode != null)
{
var lastLeaf = parseTreeNode as SyntaxTreeNode_Leaf ??
((SyntaxTreeNode_Rule)parseTreeNode).GetLastLeaf() ??
((SyntaxTreeNode_Rule)parseTreeNode).FindPreviousLeaf();
Scope_Base.completionAtLine = lastLeaf != null ? lastLeaf.Line : 0;
Scope_Base.completionAtTokenIndex = lastLeaf != null ? lastLeaf.TokenIndex : 0;
enclosingScopeNode.scope.GetCompletionData(d, true, assemblyDefinition);
}
}
completionSymbols.UnionWith(d.Values);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
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;
}
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 SD_Type_Reflected(Type type)
{
reflectedType = type;
modifiers = type.IsNested ?
(type.IsNestedPublic ? Modifiers.Public :
type.IsNestedFamORAssem ? Modifiers.Internal | Modifiers.Protected :
type.IsNestedAssembly ? Modifiers.Internal :
type.IsNestedFamily ? Modifiers.Protected :
Modifiers.Private)
:
(type.IsPublic ? Modifiers.Public :
!type.IsVisible ? Modifiers.Internal :
Modifiers.Private);
if (type.IsAbstract && type.IsSealed)
{
modifiers |= Modifiers.Static;
}
else if (type.IsAbstract)
{
modifiers |= Modifiers.Abstract;
}
else if (type.IsSealed)
{
modifiers |= Modifiers.Sealed;
}
accessLevel = AccessLevelFromModifiers(modifiers);
var assemblyDefinition = SD_Assembly.FromAssembly(type.Assembly);
var generic = type.Name.IndexOf('`');
name = generic < 0 ? type.Name : type.Name.Substring(0, generic);
name = name.Replace("[*]", "[]");
parentSymbol = string.IsNullOrEmpty(type.Namespace) ? assemblyDefinition.GlobalNamespace : assemblyDefinition.FindNamespace(type.Namespace);
if (type.IsInterface)
{
kind = SymbolKind.Interface;
}
else if (type.IsEnum)
{
kind = SymbolKind.Enum;
}
else if (type.IsValueType)
{
kind = SymbolKind.Struct;
}
else if (type.IsClass)
{
kind = SymbolKind.Class;
if (type.BaseType == typeof(System.MulticastDelegate))
{
kind = SymbolKind.Delegate;
}
}
else
{
kind = SymbolKind.None;
}
if (type.IsGenericTypeDefinition)
{
var gtd = type.GetGenericTypeDefinition() ?? type;
var tp = gtd.GetGenericArguments();
var numGenericArgs = tp.Length;
var declaringType = gtd.DeclaringType;
if (declaringType != null && declaringType.IsGenericType)
{
var parentArgs = declaringType.GetGenericArguments();
numGenericArgs -= parentArgs.Length;
}
if (numGenericArgs > 0)
{
typeParameters = new List <SD_Type_Parameter>(numGenericArgs);
for (var i = tp.Length - numGenericArgs; i < tp.Length; ++i)
{
var tpDef = new SD_Type_Parameter {
kind = SymbolKind.TypeParameter, name = tp[i].Name, parentSymbol = this
};
typeParameters.Add(tpDef);
}
}
}
if (type.BaseType != null)
{
baseType = ReflectedTypeReference.ForType(type.BaseType ?? typeof(object));
}
interfaces = new List <SymbolReference>();
var implements = type.GetInterfaces();
for (var i = 0; i < implements.Length; ++i)
{
interfaces.Add(ReflectedTypeReference.ForType(implements[i]));
}
if (IsStatic && NumTypeParameters == 0 && !type.IsNested)
{
var attributes = System.Attribute.GetCustomAttributes(type);
foreach (var attribute in attributes)
{
if (attribute is System.Runtime.CompilerServices.ExtensionAttribute)
{
ReflectAllMembers(BindingFlags.Public | BindingFlags.NonPublic);
break;
}
}
}
}
//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);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (localSymbols != null)
{
foreach (var ls in localSymbols)
{
SymbolDeclaration declaration = ls.declarations.FirstOrDefault();
SyntaxTreeNode_Rule declarationNode = declaration != null ? declaration.parseTreeNode : null;
if (declarationNode == null)
{
continue;
}
var firstLeaf = declarationNode.GetFirstLeaf();
if (firstLeaf != null &&
(firstLeaf.Line > completionAtLine ||
firstLeaf.Line == completionAtLine && firstLeaf.TokenIndex >= completionAtTokenIndex))
{
continue;
}
if (!data.ContainsKey(ls.name))
{
data.Add(ls.name, ls);
}
}
}
base.GetCompletionData(data, fromInstance, assembly);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
var baseNode = completionNode;
if (baseNode.Parent != null && (baseNode.Parent == parseTreeNode || baseNode.m_iChildIndex == 0 && baseNode.Parent.Parent == parseTreeNode))
{
SymbolDefinition target = null;
SyntaxTreeNode_Base targetNode = null;
var node = parseTreeNode
.Parent
.Parent
.Parent;
if (node.RuleName == "objectCreationExpression")
{
targetNode = node.Parent;
target = SymbolDefinition.ResolveNode(targetNode);
var targetAsType = target as TypeDefinitionBase;
if (targetAsType != null)
{
target = targetAsType.GetThisInstance();
}
}
else
{
targetNode = node.Parent.LeafAt(0);
target = SymbolDefinition.ResolveNode(node.Parent.LeafAt(0));
}
if (target != null)
{
HashSet <SymbolDefinition> completions = new HashSet <SymbolDefinition>();
SymbolResolver.GetCompletions(IdentifierCompletionsType.Member, targetNode, completions, completionAssetPath);
foreach (var symbol in completions)
{
data.Add(symbol.name, symbol);
}
}
}
else
{
base.GetCompletionData(data, fromInstance, assembly);
}
}
