static IEnumerable<IType> GetNestedTypesImpl(IType outerType, IList<IType> nestedTypeArguments, Predicate<ITypeDefinition> filter, GetMemberOptions options) { ITypeDefinition outerTypeDef = outerType.GetDefinition(); if (outerTypeDef == null) yield break; int outerTypeParameterCount = outerTypeDef.TypeParameterCount; ParameterizedType pt = outerType as ParameterizedType; foreach (ITypeDefinition nestedType in outerTypeDef.NestedTypes) { int totalTypeParameterCount = nestedType.TypeParameterCount; if (nestedTypeArguments != null) { if (totalTypeParameterCount - outerTypeParameterCount != nestedTypeArguments.Count) continue; } if (!(filter == null || filter(nestedType))) continue; if (totalTypeParameterCount == 0 || (options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) { yield return nestedType; } else { // We need to parameterize the nested type IType[] newTypeArguments = new IType[totalTypeParameterCount]; for (int i = 0; i < outerTypeParameterCount; i++) { newTypeArguments[i] = pt != null ? pt.GetTypeArgument(i) : outerTypeDef.TypeParameters[i]; } for (int i = outerTypeParameterCount; i < totalTypeParameterCount; i++) { if (nestedTypeArguments != null) newTypeArguments[i] = nestedTypeArguments[i - outerTypeParameterCount]; else newTypeArguments[i] = SpecialType.UnboundTypeArgument; } yield return new ParameterizedType(nestedType, newTypeArguments); } } }
public NormalCompletionAnalysis(VsProjectAnalyzer vsProjectAnalyzer, ITextSnapshot snapshot, VisualStudio.Text.ITrackingSpan applicableSpan, VisualStudio.Text.ITextBuffer textBuffer, GetMemberOptions options) : base(applicableSpan, textBuffer) { _analyzer = vsProjectAnalyzer; _snapshot = snapshot; _applicableSpan = applicableSpan; _textBuffer = textBuffer; _options = options; }
public static IEnumerable<IType> GetNestedTypes(IType type, IList<IType> nestedTypeArguments, Predicate<ITypeDefinition> filter, GetMemberOptions options) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) { return GetNestedTypesImpl(type, nestedTypeArguments, filter, options); } else { return type.GetNonInterfaceBaseTypes().SelectMany(t => GetNestedTypesImpl(t, nestedTypeArguments, filter, options)); } }
public override IDictionary<string, IAnalysisSet> GetAllMembers(IModuleContext moduleContext, GetMemberOptions options = GetMemberOptions.None) { var res = new Dictionary<string, IAnalysisSet>(); foreach (var kvp in _scope.AllVariables) { kvp.Value.ClearOldValues(); if (kvp.Value._dependencies.Count > 0) { var types = kvp.Value.Types; if (types.Count > 0) { res[kvp.Key] = types; } } } return res; }
public override IDictionary<string, IAnalysisSet> GetAllMembers(IModuleContext moduleContext, GetMemberOptions options = GetMemberOptions.None) { var mro = ClassInfo._mro; if (!mro.IsValid) { return new Dictionary<string, IAnalysisSet>(); } if (options.HasFlag(GetMemberOptions.DeclaredOnly)) { return Values.Mro.GetAllMembersOfMro(mro.Skip(1).Take(1), moduleContext, options); } // First item in MRO list is always the class itself. return Values.Mro.GetAllMembersOfMro(mro.Skip(1), moduleContext, options); }
public override IDictionary<string, IAnalysisSet> GetAllMembers(IModuleContext moduleContext, GetMemberOptions options = GetMemberOptions.None) { var res = new Dictionary<string, IAnalysisSet>(); if (_instanceAttrs != null) { foreach (var kvp in _instanceAttrs) { var types = kvp.Value.TypesNoCopy; var key = kvp.Key; kvp.Value.ClearOldValues(); if (kvp.Value.VariableStillExists) { MergeTypes(res, key, types); } } } // check and see if it's defined in a base class instance as well... if (!options.HasFlag(GetMemberOptions.DeclaredOnly)) { foreach (var b in _classInfo.Bases) { foreach (var ns in b) { if (ns.Push()) { try { ClassInfo baseClass = ns as ClassInfo; if (baseClass != null && baseClass.Instance._instanceAttrs != null) { foreach (var kvp in baseClass.Instance._instanceAttrs) { kvp.Value.ClearOldValues(); if (kvp.Value.VariableStillExists) { MergeTypes(res, kvp.Key, kvp.Value.TypesNoCopy); } } } } finally { ns.Pop(); } } } } foreach (var classMem in _classInfo.GetAllMembers(moduleContext)) { MergeTypes(res, classMem.Key, classMem.Value); } } return res; }
static IEnumerable<IType> GetNestedTypesImpl(IType outerType, IList<IType> nestedTypeArguments, ITypeResolveContext context, Predicate<ITypeDefinition> filter, GetMemberOptions options) { ITypeDefinition outerTypeDef = outerType.GetDefinition(); if (outerTypeDef == null) yield break; int outerTypeParameterCount = outerTypeDef.TypeParameterCount; ParameterizedType pt = outerType as ParameterizedType; foreach (ITypeDefinition nestedType in outerTypeDef.NestedTypes) { int totalTypeParameterCount = nestedType.TypeParameterCount; if (nestedTypeArguments != null) { if (totalTypeParameterCount - outerTypeParameterCount != nestedTypeArguments.Count) continue; } if (!(filter == null || filter(nestedType))) continue; if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) { yield return nestedType; } else if (totalTypeParameterCount == 0 || (pt == null && totalTypeParameterCount == outerTypeParameterCount)) { // The nested type has no new type parameters, and there are no type arguments // to copy from the outer type // -> we can directly return the nested type definition yield return nestedType; } else { // We need to parameterize the nested type IType[] newTypeArguments = new IType[totalTypeParameterCount]; for (int i = 0; i < outerTypeParameterCount; i++) { newTypeArguments[i] = pt != null ? pt.GetTypeArgument(i) : outerTypeDef.TypeParameters[i]; } for (int i = outerTypeParameterCount; i < totalTypeParameterCount; i++) { if (nestedTypeArguments != null) newTypeArguments[i] = nestedTypeArguments[i - outerTypeParameterCount]; else newTypeArguments[i] = SharedTypes.UnboundTypeArgument; } yield return new ParameterizedType(nestedType, newTypeArguments); } } }
public IDictionary <string, IAnalysisSet> GetAllMembers(IModuleContext moduleContext, GetMemberOptions options) { return(GetAllMembersOfMro(this, moduleContext, options)); }
public IEnumerable <IMethod> GetConstructors(Predicate <IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) { if (this.HasDefaultConstructorConstraint || this.HasValueTypeConstraint) { if (filter == null || filter(dummyConstructor)) { var resolvedCtor = (IMethod)dummyConstructor.CreateResolved(compilation.TypeResolveContext); IMethod m = new SpecializedMethod(this, resolvedCtor, EmptyList <IType> .Instance); return(new [] { m }); } } return(EmptyList <IMethod> .Instance); } else { return(GetMembersHelper.GetConstructors(this, filter, options)); } }
public override IEnumerable <IMethod> GetMethods(IReadOnlyList <IType> typeArguments, Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) { return(EmptyList <IMethod> .Instance); } else { return(compilation.FindType(KnownTypeCode.Array).GetMethods(typeArguments, filter, options)); } }
public override IEnumerable <IMethod> GetConstructors(Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) { return(elementType.GetConstructors(filter, options)); }
public IEnumerable<IMethod> GetMethods(IList<IType> typeArguments, Predicate<IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) return genericType.GetMethods(typeArguments, filter, options); else return GetMembersHelper.GetMethods(this, typeArguments, filter, options); }
internal static DynamicMetaObject FallbackWorker(DynamicMetaObject/*!*/ self, Expression/*!*/ codeContext, string name, GetMemberOptions options, DynamicMetaObjectBinder action) { if (self.NeedsDeferral()) { return action.Defer(self); } bool isNoThrow = ((options & GetMemberOptions.IsNoThrow) != 0) ? true : false; Type limitType = self.GetLimitType() ; if (limitType == typeof(DynamicNull) || PythonBinder.IsPythonType(limitType)) { // look up in the PythonType so that we can // get our custom method names (e.g. string.startswith) PythonType argType = DynamicHelpers.GetPythonTypeFromType(limitType); // if the name is defined in the CLS context but not the normal context then // we will hide it. if (argType.IsHiddenMember(name)) { DynamicMetaObject baseRes = BinderState.GetBinderState(action).Binder.GetMember( name, self, codeContext, isNoThrow ); Expression failure = GetFailureExpression(limitType, name, isNoThrow, action); return BindingHelpers.FilterShowCls(codeContext, action, baseRes, failure); } } if (self.GetLimitType() == typeof(OldInstance)) { if ((options & GetMemberOptions.IsNoThrow) != 0) { return new DynamicMetaObject( Ast.Field( null, typeof(OperationFailed).GetField("Value") ), self.Restrictions.Merge(BindingRestrictionsHelpers.GetRuntimeTypeRestriction(self.Expression, typeof(OldInstance))) ); } else { return new DynamicMetaObject( Ast.Throw( Ast.Call( typeof(PythonOps).GetMethod("AttributeError"), Ast.Constant("{0} instance has no attribute '{1}'"), Ast.NewArrayInit( typeof(object), Ast.Constant(((OldInstance)self.Value)._class._name), Ast.Constant(name) ) ) ), self.Restrictions.Merge(BindingRestrictionsHelpers.GetRuntimeTypeRestriction(self.Expression, typeof(OldInstance))) ); } } var res = BinderState.GetBinderState(action).Binder.GetMember(name, self, codeContext, isNoThrow); // Default binder can return something typed to boolean or int. // If that happens, we need to apply Python's boxing rules. if (res.Expression.Type == typeof(bool) || res.Expression.Type == typeof(int)) { res = new DynamicMetaObject( AstUtils.Convert(res.Expression, typeof(object)), res.Restrictions ); } return res; }
public virtual IEnumerable <IEvent> GetEvents(Predicate <IEvent> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(EmptyList <IEvent> .Instance); }
public override IEnumerable<IMethod> GetMethods(IList<IType> typeArguments, Predicate<IUnresolvedMethod> filter, GetMemberOptions options) { return EmptyList<IMethod>.Instance; }
public virtual IEnumerable <IMethod> GetConstructors(Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) { return(EmptyList <IMethod> .Instance); }
public virtual IEnumerable <IProperty> GetProperties(Predicate <IProperty> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(EmptyList <IProperty> .Instance); }
public virtual IEnumerable <IMethod> GetMethods(IReadOnlyList <IType> typeArguments, Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(EmptyList <IMethod> .Instance); }
public override IDictionary <string, IAnalysisSet> GetAllMembers(IModuleContext moduleContext, GetMemberOptions options = GetMemberOptions.None) { if (!options.HasFlag(GetMemberOptions.DeclaredOnly) && (_functionAttrs == null || _functionAttrs.Count == 0)) { return(ProjectState.ClassInfos[BuiltinTypeId.Function].GetAllMembers(moduleContext, options)); } Dictionary <string, IAnalysisSet> res; if (options.HasFlag(GetMemberOptions.DeclaredOnly)) { res = new Dictionary <string, IAnalysisSet>(); } else { res = new Dictionary <string, IAnalysisSet>(ProjectState.ClassInfos[BuiltinTypeId.Function].Instance.GetAllMembers(moduleContext)); } if (_functionAttrs != null) { foreach (var variable in _functionAttrs) { IAnalysisSet existing; if (!res.TryGetValue(variable.Key, out existing)) { res[variable.Key] = variable.Value.Types; } else { res[variable.Key] = existing.Union(variable.Value.TypesNoCopy); } } } return(res); }
public IEnumerable <IMember> GetMembers(Predicate <IUnresolvedMember> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) { return(EmptyList <IMember> .Instance); } else { return(GetMembersHelper.GetMembers(this, FilterNonStatic(filter), options)); } }
internal IEnumerable<MemberResult> GetMemberResults( IEnumerable<AnalysisValue> vars, InterpreterScope scope, GetMemberOptions options ) { IList<AnalysisValue> namespaces = new List<AnalysisValue>(); foreach (var ns in vars) { if (ns != null) { namespaces.Add(ns); } } if (namespaces.Count == 1) { // optimize for the common case of only a single namespace var newMembers = namespaces[0].GetAllMembers(GlobalScope.InterpreterContext, options); if (newMembers == null || newMembers.Count == 0) { return new MemberResult[0]; } return SingleMemberResult(GetPrivatePrefix(scope), options, newMembers); } Dictionary<string, IEnumerable<AnalysisValue>> memberDict = null; Dictionary<string, IEnumerable<AnalysisValue>> ownerDict = null; HashSet<string> memberSet = null; int namespacesCount = namespaces.Count; foreach (AnalysisValue ns in namespaces) { if (ProjectState._noneInst == ns) { namespacesCount -= 1; continue; } var newMembers = ns.GetAllMembers(GlobalScope.InterpreterContext, options); // IntersectMembers(members, memberSet, memberDict); if (newMembers == null || newMembers.Count == 0) { continue; } if (memberSet == null) { // first namespace, add everything memberSet = new HashSet<string>(newMembers.Keys); memberDict = new Dictionary<string, IEnumerable<AnalysisValue>>(); ownerDict = new Dictionary<string, IEnumerable<AnalysisValue>>(); foreach (var kvp in newMembers) { var tmp = new List<AnalysisValue>(kvp.Value); memberDict[kvp.Key] = tmp; ownerDict[kvp.Key] = new List<AnalysisValue> { ns }; } } else { // 2nd or nth namespace, union or intersect HashSet<string> toRemove; IEnumerable<string> adding; if (options.Intersect()) { adding = new HashSet<string>(newMembers.Keys); // Find the things only in memberSet that we need to remove from memberDict // toRemove = (memberSet ^ adding) & memberSet toRemove = new HashSet<string>(memberSet); toRemove.SymmetricExceptWith(adding); toRemove.IntersectWith(memberSet); // intersect memberSet with what we're adding memberSet.IntersectWith(adding); // we're only adding things they both had adding = memberSet; } else { // we're adding all of newMembers keys adding = newMembers.Keys; toRemove = null; } // update memberDict foreach (var name in adding) { IEnumerable<AnalysisValue> values; List<AnalysisValue> valueList; if (!memberDict.TryGetValue(name, out values)) { memberDict[name] = values = new List<AnalysisValue>(); } if ((valueList = values as List<AnalysisValue>) == null) { memberDict[name] = valueList = new List<AnalysisValue>(values); } valueList.AddRange(newMembers[name]); if (!ownerDict.TryGetValue(name, out values)) { ownerDict[name] = values = new List<AnalysisValue>(); } if ((valueList = values as List<AnalysisValue>) == null) { ownerDict[name] = valueList = new List<AnalysisValue>(values); } valueList.Add(ns); } if (toRemove != null) { foreach (var name in toRemove) { memberDict.Remove(name); ownerDict.Remove(name); } } } } if (memberDict == null) { return new MemberResult[0]; } if (options.Intersect()) { // No need for this information if we're only showing the // intersection. Setting it to null saves lookups later. ownerDict = null; } return MemberDictToResultList(GetPrivatePrefix(scope), options, memberDict, ownerDict, namespacesCount); }
public virtual IEnumerable <IMember> GetMembers(Predicate <IMember> filter = null, GetMemberOptions options = GetMemberOptions.None) { IEnumerable <IMember> members = GetMethods(filter, options); return(members .Concat(GetProperties(filter, options)) .Concat(GetFields(filter, options)) .Concat(GetEvents(filter, options))); }
private static IEnumerable<MemberResult> MemberDictToResultList( string privatePrefix, GetMemberOptions options, Dictionary<string, IEnumerable<AnalysisValue>> memberDict, Dictionary<string, IEnumerable<AnalysisValue>> ownerDict = null, int maximumOwners = 0 ) { foreach (var kvp in memberDict) { string name = GetMemberName(privatePrefix, options, kvp.Key); string completion = name; if (name != null) { IEnumerable<AnalysisValue> owners; if (ownerDict != null && ownerDict.TryGetValue(kvp.Key, out owners) && owners.Any() && owners.Count() < maximumOwners) { // This member came from less than the full set of types. var seenNames = new HashSet<string>(); var newName = new StringBuilder(name); newName.Append(" ("); foreach (var v in owners) { if (!string.IsNullOrWhiteSpace(v.ShortDescription) && seenNames.Add(v.ShortDescription)) { // Restrict each displayed type to 25 characters if (v.ShortDescription.Length > 25) { newName.Append(v.ShortDescription.Substring(0, 22)); newName.Append("..."); } else { newName.Append(v.ShortDescription); } newName.Append(", "); } if (newName.Length > 200) break; } // Restrict the entire completion string to 200 characters if (newName.Length > 200) { newName.Length = 197; // Avoid showing more than three '.'s in a row while (newName[newName.Length - 1] == '.') { newName.Length -= 1; } newName.Append("..."); } else { newName.Length -= 2; } newName.Append(")"); name = newName.ToString(); } yield return new MemberResult(name, completion, kvp.Value, null); } } }
public virtual IEnumerable <IMethod> GetAccessors(Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(EmptyList <IMethod> .Instance); }
public override IEnumerable<IMember> GetMembers(Predicate<IUnresolvedMember> filter, GetMemberOptions options) { return EmptyList<IMember>.Instance; }
public virtual IEnumerable <IType> GetNestedTypes(IReadOnlyList <IType> typeArguments, Predicate <ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(EmptyList <IType> .Instance); }
public IEnumerable<IMethod> GetAccessors(Predicate<IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) return genericType.GetAccessors(filter, options); else return GetMembersHelper.GetAccessors(this, filter, options); }
public override IEnumerable <IProperty> GetProperties(Predicate <IProperty> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) { return(EmptyList <IProperty> .Instance); } else { return(compilation.FindType(KnownTypeCode.Array).GetProperties(filter, options)); } }
public override IEnumerable<IMethod> GetAccessors(Predicate<IUnresolvedMethod> filter, GetMemberOptions options) { for (int i = 0; i < unresolvedProperties.Length; i++) { if (unresolvedProperties[i].CanGet) { if (filter == null || filter(unresolvedProperties[i].Getter)) yield return resolvedProperties[i].Getter; } if (unresolvedProperties[i].CanSet) { if (filter == null || filter(unresolvedProperties[i].Setter)) yield return resolvedProperties[i].Setter; } } }
private static IEnumerable<MemberResult> SingleMemberResult(string privatePrefix, GetMemberOptions options, IDictionary<string, IAnalysisSet> memberDict) { foreach (var kvp in memberDict) { string name = GetMemberName(privatePrefix, options, kvp.Key); if (name != null) { yield return new MemberResult(name, kvp.Value); } } }
public override IEnumerable <IMethod> GetAccessors(Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(elementType.GetAccessors(filter, options)); }
/// <summary> /// Gets the available names at the given location. This includes /// built-in variables, global variables, and locals. /// </summary> /// <param name="location"> /// The location in the file where the available members should be /// looked up. /// </param> /// <remarks>New in 2.2</remarks> public IEnumerable<MemberResult> GetAllAvailableMembers(SourceLocation location, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults) { var result = new Dictionary<string, IEnumerable<AnalysisValue>>(); // collect builtins if (!options.HasFlag(GetMemberOptions.ExcludeBuiltins)) { foreach (var variable in ProjectState.BuiltinModule.GetAllMembers(ProjectState._defaultContext)) { result[variable.Key] = new List<AnalysisValue>(variable.Value); } } // collect variables from user defined scopes var scope = FindScope(location); foreach (var s in scope.EnumerateTowardsGlobal) { foreach (var kvp in s.GetAllMergedVariables()) { // deliberately overwrite variables from outer scopes result[kvp.Key] = new List<AnalysisValue>(kvp.Value.TypesNoCopy); } } var res = MemberDictToResultList(GetPrivatePrefix(scope), options, result); if (options.Keywords()) { res = GetKeywordMembers(options, scope).Union(res); } return res; }
/// <summary> /// Compute a list of all members, given the MRO list of types, and taking override rules into account. /// </summary> public static IDictionary <string, IAnalysisSet> GetAllMembersOfMro(IEnumerable <IAnalysisSet> mro, IModuleContext moduleContext, GetMemberOptions options) { var result = new Dictionary <string, IAnalysisSet>(); // MRO is a list of namespaces corresponding to classes, but each entry can be a union of several different classes. // Therefore, within a single entry, we want to make a union of members from each; but between entries, we // want the first entry in MRO to suppress any members with the same names from the following entries. foreach (var entry in mro) { var entryMembers = new Dictionary <string, IAnalysisSet>(); foreach (var ns in entry) { // If it's another non-builtin class, we don't want its inherited members, since we'll account // for them while processing our own MRO - we only want its immediate members. var classInfo = ns as ClassInfo; var classMembers = classInfo != null?classInfo.GetAllImmediateMembers(moduleContext, options) : ns.GetAllMembers(moduleContext); foreach (var kvp in classMembers) { IAnalysisSet existing; if (!entryMembers.TryGetValue(kvp.Key, out existing)) { entryMembers[kvp.Key] = kvp.Value; } else { entryMembers[kvp.Key] = existing.Union(kvp.Value); } } } foreach (var member in entryMembers) { if (!result.ContainsKey(member.Key)) { result.Add(member.Key, member.Value); } } } return(result); }
/// <summary> /// Evaluates a given expression and returns a list of members which /// exist in the expression. /// /// If the expression is an empty string returns all available members /// at that location. /// </summary> /// <param name="exprText">The expression to find members for.</param> /// </param> /// <param name="location"> /// The location in the file where the expression should be evaluated. /// </param> /// <remarks>New in 2.2</remarks> public IEnumerable<MemberResult> GetMembers( string exprText, SourceLocation location, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults ) { if (exprText.Length == 0) { return GetAllAvailableMembers(location, options); } var scope = FindScope(location); var privatePrefix = GetPrivatePrefixClassName(scope); var expr = Statement.GetExpression(GetAstFromText(exprText, privatePrefix).Body); if (expr is ConstantExpression && ((ConstantExpression)expr).Value is int) { // no completions on integer ., the user is typing a float return Enumerable.Empty<MemberResult>(); } var errorWalker = new ErrorWalker(); expr.Walk(errorWalker); if (errorWalker.HasError) { return null; } var unit = GetNearestEnclosingAnalysisUnit(scope); var eval = new ExpressionEvaluator(unit.CopyForEval(), scope, mergeScopes: true); IAnalysisSet lookup; if (options.HasFlag(GetMemberOptions.NoMemberRecursion)) { lookup = eval.EvaluateNoMemberRecursion(expr); } else { lookup = eval.Evaluate(expr); } return GetMemberResults(lookup, scope, options); }
public override IEnumerable <MemberResult> GetAllAvailableMembersByIndex(int index, IReverseTokenizer revTokenizer, out bool includePublicFunctions, out bool includeDatabaseTables, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults) { includePublicFunctions = false; includeDatabaseTables = false; return(new MemberResult[0]); }
public override IDictionary <string, IAnalysisSet> GetAllMembers(IModuleContext moduleContext, GetMemberOptions options = GetMemberOptions.None) { EnsureMembers(); return(_members); }
private AP.Completion[] ToCompletions(MemberResult[] memberResult, GetMemberOptions options) { AP.Completion[] res = new AP.Completion[memberResult.Length]; for (int i = 0; i < memberResult.Length; i++) { var member = memberResult[i]; res[i] = new AP.Completion() { name = member.Name, completion = member.Completion, doc = member.Documentation, memberType = member.MemberType }; if (options.HasFlag(GetMemberOptions.DetailedInformation)) { List<AP.CompletionValue> values = new List<AnalysisProtocol.CompletionValue>(); foreach (var value in member.Values) { var descComps = Array.Empty<AP.DescriptionComponent>(); var hasDesc = value as IHasRichDescription; if (hasDesc != null) { descComps = hasDesc .GetRichDescription() .Select(kv => new AP.DescriptionComponent(kv.Value, kv.Key)) .ToArray(); } values.Add( new AP.CompletionValue() { description = descComps, doc = value.Documentation, locations = value.Locations.Select(x => MakeReference(x, VariableType.Definition)).ToArray() } ); } res[i].detailedValues = values.ToArray(); } } return res; }
public override IEnumerable <MemberResult> GetContextMembers(int index, IReverseTokenizer revTokenizer, IFunctionInformationProvider functionProvider, IDatabaseInformationProvider databaseProvider, IProgramFileProvider programFileProvider, out bool includePublicFunctions, out bool includeDatabaseTables, string contextStr, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults) { includePublicFunctions = false; includeDatabaseTables = false; return(new MemberResult[0]); }
private IEnumerable<MemberResult> GetKeywordMembers(GetMemberOptions options, InterpreterScope scope) { IEnumerable<string> keywords = null; if (options.ExpressionKeywords()) { // keywords available in any context keywords = PythonKeywords.Expression(ProjectState.LanguageVersion); } else { keywords = Enumerable.Empty<string>(); } if (options.StatementKeywords()) { keywords = keywords.Union(PythonKeywords.Statement(ProjectState.LanguageVersion)); } if (!(scope is FunctionScope)) { keywords = keywords.Except(PythonKeywords.InvalidOutsideFunction(ProjectState.LanguageVersion)); } return keywords.Select(kw => new MemberResult(kw, PythonMemberType.Keyword)); }
public IEnumerable <IMethod> GetConstructors(Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) { return(genericType.GetConstructors(filter, options)); } else { return(GetMembersHelper.GetConstructors(this, filter, options)); } }
/// <summary> /// Gets the available names at the given location. This includes /// built-in variables, global variables, and locals. /// </summary> /// <param name="index"> /// The 0-based absolute index into the file where the available members /// should be looked up. /// </param> public IEnumerable<MemberResult> GetAllAvailableMembersByIndex( int index, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults ) { return GetAllAvailableMembers(_unit.Tree.IndexToLocation(index), options); }
public IEnumerable <IMethod> GetMethods(IReadOnlyList <IType> typeArguments, Predicate <IMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) { return(genericType.GetMethods(typeArguments, filter, options)); } else { return(GetMembersHelper.GetMethods(this, typeArguments, filter, options)); } }
/// <summary> /// Evaluates a given expression and returns a list of members which /// exist in the expression. /// /// If the expression is an empty string returns all available members /// at that location. /// </summary> /// <param name="exprText">The expression to find members for.</param> /// <param name="index"> /// The 0-based absolute index into the file where the expression should /// be evaluated. /// </param> public IEnumerable<MemberResult> GetMembersByIndex( string exprText, int index, GetMemberOptions options = GetMemberOptions.IntersectMultipleResults ) { return GetMembers(exprText, _unit.Tree.IndexToLocation(index), options); }
public IEnumerable <IProperty> GetProperties(Predicate <IProperty> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) { return(genericType.GetProperties(filter, options)); } else { return(GetMembersHelper.GetProperties(this, filter, options)); } }
private static string GetMemberName(string privatePrefix, GetMemberOptions options, string name) { if (privatePrefix != null && name.StartsWith(privatePrefix) && !name.EndsWith("__")) { // private prefix inside of the class, filter out the prefix. return name.Substring(privatePrefix.Length - 2); } else if (!_otherPrivateRegex.IsMatch(name) || !options.HideAdvanced()) { return name; } return null; }
IEnumerable <IEvent> IType.GetEvents(Predicate <IEvent> filter, GetMemberOptions options) { return(EmptyList <IEvent> .Instance); }
public override IEnumerable<IMember> GetMembers(ITypeResolveContext context, Predicate<IMember> filter, GetMemberOptions options) { return EmptyList<IMember>.Instance; }
IEnumerable <IMethod> IType.GetMethods(Predicate <IMethod> filter, GetMemberOptions options) { return(EmptyList <IMethod> .Instance); }
public override IEnumerable<IProperty> GetProperties(Predicate<IUnresolvedProperty> filter, GetMemberOptions options) { return EmptyList<IProperty>.Instance; }
IEnumerable <IMethod> IType.GetMethods(IReadOnlyList <IType> typeArguments, Predicate <IMethod> filter, GetMemberOptions options) { return(EmptyList <IMethod> .Instance); }
public IEnumerable<IType> GetNestedTypes(Predicate<ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) return genericType.GetNestedTypes(filter, options); else return GetMembersHelper.GetNestedTypes(this, filter, options); }
IEnumerable <IType> IType.GetNestedTypes(IReadOnlyList <IType> typeArguments, Predicate <ITypeDefinition> filter, GetMemberOptions options) { return(EmptyList <IType> .Instance); }
public IEnumerable<IProperty> GetProperties(Predicate<IUnresolvedProperty> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) return genericType.GetProperties(filter, options); else return GetMembersHelper.GetProperties(this, filter, options); }
IEnumerable <IProperty> IType.GetProperties(Predicate <IProperty> filter, GetMemberOptions options) { return(EmptyList <IProperty> .Instance); }
public PythonGetMemberBinder(BinderState/*!*/ binder, string/*!*/ name, bool isNoThrow) : this(binder, name) { _options = isNoThrow ? GetMemberOptions.IsNoThrow : GetMemberOptions.None; }
public override IEnumerable <IType> GetNestedTypes(IReadOnlyList <IType> typeArguments, Predicate <ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(elementType.GetNestedTypes(typeArguments, filter, options)); }
public override IEnumerable<IProperty> GetProperties(Predicate<IUnresolvedProperty> filter = null, GetMemberOptions options = GetMemberOptions.None) { for (int i = 0; i < unresolvedProperties.Length; i++) { if (filter == null || filter(unresolvedProperties[i])) yield return resolvedProperties[i]; } }
public override IEnumerable <IType> GetNestedTypes(Predicate <ITypeDefinition> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(elementType.GetNestedTypes(filter, options)); }
public override IEnumerable<IMethod> GetMethods(Predicate<IUnresolvedMethod> filter = null, GetMemberOptions options = GetMemberOptions.None) { if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) return EmptyList<IMethod>.Instance; else return compilation.FindType(KnownTypeCode.Object).GetMethods(filter, options); }
public override IEnumerable <IProperty> GetProperties(Predicate <IProperty> filter = null, GetMemberOptions options = GetMemberOptions.None) { return(elementType.GetProperties(filter, options)); }