public static bool TryGetCompletions(ForStatement forStatement, CompletionContext context, out CompletionResult result)
{
result = null;
if (forStatement.Left == null)
{
return(false);
}
if (forStatement.InIndex > forStatement.StartIndex)
{
if (context.Position > forStatement.InIndex + 2)
{
return(false);
}
if (context.Position >= forStatement.InIndex)
{
var applicableSpan = new SourceSpan(
context.IndexToLocation(forStatement.InIndex),
context.IndexToLocation(forStatement.InIndex + 2)
);
result = new CompletionResult(Enumerable.Repeat(CompletionItemSource.InKeyword, 1), applicableSpan);
return(true);
}
}
if (forStatement.Left.StartIndex > forStatement.StartIndex &&
forStatement.Left.EndIndex > forStatement.Left.StartIndex &&
context.Position > forStatement.Left.EndIndex)
{
var applicableSpan = context.GetApplicableSpanFromLastToken(forStatement);
result = new CompletionResult(Enumerable.Repeat(CompletionItemSource.InKeyword, 1), applicableSpan);
return(true);
}
return(forStatement.ForIndex >= forStatement.StartIndex && context.Position > forStatement.ForIndex + 3);
}
public static bool TryGetCompletions(WithStatement withStatement, CompletionContext context, out CompletionResult result)
{
result = CompletionResult.Empty;
if (context.Position > withStatement.HeaderIndex && withStatement.HeaderIndex > withStatement.StartIndex)
{
return(false);
}
foreach (var item in withStatement.Items.Reverse().MaybeEnumerate())
{
if (item.AsIndex > item.StartIndex)
{
if (context.Position > item.AsIndex + 2)
{
return(true);
}
if (context.Position >= item.AsIndex)
{
var applicableSpan = new SourceSpan(context.IndexToLocation(item.AsIndex), context.IndexToLocation(item.AsIndex + 2));
result = new CompletionResult(Enumerable.Repeat(CompletionItemSource.AsKeyword, 1), applicableSpan);
return(true);
}
}
if (item.ContextManager != null && !(item.ContextManager is ErrorExpression))
{
if (context.Position > item.ContextManager.EndIndex && item.ContextManager.EndIndex > item.ContextManager.StartIndex)
{
result = result = new CompletionResult(Enumerable.Repeat(CompletionItemSource.AsKeyword, 1));
return(true);
}
if (context.Position >= item.ContextManager.StartIndex)
{
return(false);
}
}
}
return(false);
}
public static CompletionResult GetCompletionsInFromImport(FromImportStatement fromImport, CompletionContext context)
{
// No more completions after '*', ever!
if (fromImport.Names != null && fromImport.Names.Any(n => n?.Name == "*" && context.Position > n.EndIndex))
{
return(CompletionResult.Empty);
}
var document = context.Analysis.Document;
var mres = document.Interpreter.ModuleResolution;
foreach (var(name, asName) in ZipLongest(fromImport.Names, fromImport.AsNames).Reverse())
{
if (asName != null && context.Position >= asName.StartIndex)
{
return(CompletionResult.Empty);
}
if (name != null)
{
if (context.Position > name.EndIndex && name.EndIndex > name.StartIndex)
{
var applicableSpan = context.GetApplicableSpanFromLastToken(fromImport);
return(new CompletionResult(Enumerable.Repeat(CompletionItemSource.AsKeyword, 1), applicableSpan));
}
if (context.Position >= name.StartIndex)
{
var applicableSpan = name.GetSpan(context.Ast);
var importSearchResult = mres.CurrentPathResolver.FindImports(document.FilePath, fromImport);
return(GetResultFromImportSearch(importSearchResult, context, false, applicableSpan));
}
}
}
if (fromImport.ImportIndex > fromImport.StartIndex && context.Position > fromImport.ImportIndex + 6)
{
var importSearchResult = mres.CurrentPathResolver.FindImports(document.FilePath, fromImport);
var result = GetResultFromImportSearch(importSearchResult, context, true);
if (result != CompletionResult.Empty)
{
return(result);
}
}
if (fromImport.ImportIndex > 0 && context.Position >= fromImport.ImportIndex)
{
var applicableSpan = new SourceSpan(
context.IndexToLocation(fromImport.ImportIndex),
context.IndexToLocation(Math.Min(fromImport.ImportIndex + 6, fromImport.EndIndex))
);
return(new CompletionResult(Enumerable.Repeat(CompletionItemSource.ImportKeyword, 1), applicableSpan));
}
if (context.Position > fromImport.Root.EndIndex && fromImport.Root.EndIndex > fromImport.Root.StartIndex)
{
SourceSpan?applicableSpan = null;
if (context.Position > fromImport.EndIndex)
{
// Only end up here for "from ... imp", and "imp" is not counted
// as part of our span
var token = context.TokenSource.Tokens.LastOrDefault();
if (token.Key.End >= context.Position)
{
applicableSpan = context.TokenSource.GetTokenSpan(token.Key);
}
}
return(new CompletionResult(Enumerable.Repeat(CompletionItemSource.ImportKeyword, 1), applicableSpan));
}
if (context.Position > fromImport.Root.StartIndex && fromImport.Root is RelativeModuleName relativeName)
{
var rootNames = relativeName.Names.Select(n => n.Name);
var importSearchResult = mres.CurrentPathResolver.GetImportsFromRelativePath(document.FilePath, relativeName.DotCount, rootNames);
return(GetResultFromImportSearch(importSearchResult, context, false));
}
if (fromImport.Root.Names.Count > 1 && context.Position > fromImport.Root.Names[0].EndIndex)
{
var rootNames = fromImport.Root.Names.TakeWhile(n => n.EndIndex < context.Position).Select(n => n.Name);
var importSearchResult = mres.CurrentPathResolver.GetImportsFromAbsoluteName(document.FilePath, rootNames, fromImport.ForceAbsolute);
return(GetResultFromImportSearch(importSearchResult, context, false));
}
return(context.Position > fromImport.KeywordEndIndex
? new CompletionResult(GetAllImportableModules(context))
: null);
}
public static CompletionResult GetCompletions(Node statement, ScopeStatement scopeStatement, CompletionContext context)
{
SourceSpan?applicableSpan = null;
var eval = context.Analysis.ExpressionEvaluator;
var options = GetOptions(statement, context.Position, out var span);
if (span.HasValue)
{
applicableSpan = new SourceSpan(context.IndexToLocation(span.Value.Start), context.IndexToLocation(span.Value.End));
}
var scope = context.Analysis.FindScope(context.Location);
IEnumerable <CompletionItem> items;
using (eval.OpenScope(scope)) {
// Get variables declared in the module.
var variables = eval.CurrentScope.EnumerateTowardsGlobal.SelectMany(s => s.Variables).ToArray();
items = variables.Select(v => context.ItemSource.CreateCompletionItem(v.Name, v)).ToArray();
}
// Get builtins
var builtins = context.Analysis.Document.Interpreter.ModuleResolution.BuiltinsModule;
var builtinItems = builtins.GetMemberNames()
.Select(n => {
var m = builtins.GetMember(n);
if ((options & CompletionListOptions.ExceptionsOnly) == CompletionListOptions.ExceptionsOnly && !IsExceptionType(m.GetPythonType()))
{
return(null);
}
return(context.ItemSource.CreateCompletionItem(n, m));
}).ExcludeDefault();
items = items.Concat(builtinItems);
// Add possible function arguments.
var finder = new ExpressionFinder(context.Ast, new FindExpressionOptions {
Calls = true
});
if (finder.GetExpression(context.Position) is CallExpression callExpr && callExpr.GetArgumentAtIndex(context.Ast, context.Position, out _))
{
var value = eval.GetValueFromExpression(callExpr.Target);
if (value?.GetPythonType() is IPythonFunctionType ft)
{
var arguments = ft.Overloads.SelectMany(o => o.Parameters).Select(p => p?.Name)
.Where(n => !string.IsNullOrEmpty(n))
.Distinct()
.Except(callExpr.Args.MaybeEnumerate().Select(a => a.Name).Where(n => !string.IsNullOrEmpty(n)))
.Select(n => CompletionItemSource.CreateCompletionItem($"{n}=", CompletionItemKind.Variable))
.ToArray();
items = items.Concat(arguments).ToArray();
}
}
var keywords = GetKeywordItems(context, options, scopeStatement);
items = items.Concat(keywords);
return(new CompletionResult(items, applicableSpan));
}