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); } }