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