public virtual void PostWalk(FromImportStatement node)
 {
 }
 public override void PostWalk(FromImportStatement node)
 {
 }
예제 #3
0
 public RemovedFromImportStatement(FromImportStatement fromImport)
 {
     _fromImport = fromImport;
 }
        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);
        }
예제 #5
0
 public override void PostWalk(FromImportStatement node)
 {
     PostWalkWorker(node);
 }
        public static IImportSearchResult FindImports(this PathResolverSnapshot pathResolver, string modulePath, FromImportStatement fromImportStatement)
        {
            var rootNames = fromImportStatement.Root.Names.Select(n => n.Name);

            return(fromImportStatement.Root is RelativeModuleName relativeName
                ? pathResolver.GetImportsFromRelativePath(modulePath, relativeName.DotCount, rootNames)
                : pathResolver.GetImportsFromAbsoluteName(modulePath, rootNames, fromImportStatement.ForceAbsolute));
        }
예제 #7
0
 private List <Inferred> InferFromImportStatement(FromImportStatement node, Scope scope)
 {
     Debug.Print("Not implemented: InferFromImportStatementIn");
     return(null);
 }
예제 #8
0
        /// <summary>
        /// Extracts actual module names from the 'from import' statement
        /// such as [a, b, c] from 'from . import a, b, c' or [a] from 'from .a import b, c'
        /// </summary>
        /// <param name="importingFromModuleName">Name of the importing module</param>
        /// <param name="importingFromFilePath">Disk path to the importing module</param>
        /// <param name="node">Import statement node</param>
        /// <returns></returns>
        internal static IEnumerable <string> GetModuleNamesFromImport(string importingFromModuleName, string importingFromFilePath, FromImportStatement node)
        {
            var root = node.Root.MakeString();

            if (!string.IsNullOrEmpty(root) && root.StartsWithOrdinal("."))
            {
                return(root.All(c => c == '.')
                    ? node.Names.Where(n => !string.IsNullOrEmpty(n.Name)).Select(n => n.Name)
                    : ResolvePotentialModuleNames(importingFromModuleName, importingFromFilePath, root, node.ForceAbsolute));
            }
            return(new[] { root });
        }
예제 #9
0
        public override bool Walk(FromImportStatement node)
        {
            var modName = node.Root.MakeString();

            if (!TryImportModule(modName, node.ForceAbsolute, out var modRef, out var bits))
            {
                _unit.DeclaringModule.AddUnresolvedModule(modName, node.ForceAbsolute);
                return(false);
            }

            Debug.Assert(modRef.Module != null);
            modRef.Module.Imported(_unit);

            string[] fullImpName;
            if (bits != null)
            {
                fullImpName = new string[bits.Count + 1];
                bits.ToArray().CopyTo(fullImpName, 0);
            }
            else
            {
                fullImpName = new string[1];
            }

            var asNames = node.AsNames ?? node.Names;

            int len = Math.Min(node.Names.Count, asNames.Count);

            for (int i = 0; i < len; i++)
            {
                var impName = node.Names[i].Name;

                if (string.IsNullOrEmpty(impName))
                {
                    // incomplete import statement
                    continue;
                }
                else if (impName == "*")
                {
                    // Handle "import *"
                    foreach (var varName in modRef.Module.GetModuleMemberNames(GlobalScope.InterpreterContext))
                    {
                        if (!varName.StartsWithOrdinal("_"))
                        {
                            fullImpName[fullImpName.Length - 1] = varName;

                            // Don't add references to "*" node
                            FinishImportModuleOrMember(modRef, fullImpName, varName, false, node.Names[i], null);
                        }
                    }
                }
                else
                {
                    fullImpName[fullImpName.Length - 1] = impName;

                    var varName = asNames[i]?.Name ?? impName;
                    FinishImportModuleOrMember(modRef, fullImpName, varName, true, node.Names[i], asNames[i]);
                }
            }

            return(false);
        }
예제 #10
0
 public RemovedFromImportStatement(FromImportStatement fromImport, PythonAst ast)
 {
     _fromImport       = fromImport;
     LeadingWhitespace = fromImport.GetPreceedingWhiteSpaceDefaultNull(ast);
 }
예제 #11
0
파일: DDG.cs 프로젝트: pdiemi/PTVS
        public override bool Walk(FromImportStatement node)
        {
            var modName = node.Root.MakeString();

            if (!TryImportModule(modName, node.ForceAbsolute, out var modRef, out var bits))
            {
                _unit.DeclaringModule.AddUnresolvedModule(modName, node.ForceAbsolute);
                return(false);
            }

            _unit.DeclaringModule.AddModuleReference(modRef);

            Debug.Assert(modRef.Module != null);
            var userMod = modRef.Module;

            string[] fullImpName;
            if (bits != null)
            {
                fullImpName = new string[bits.Count + 1];
                bits.ToArray().CopyTo(fullImpName, 0);
            }
            else
            {
                fullImpName = new string[1];
            }

            var asNames = node.AsNames ?? node.Names;

            int len = Math.Min(node.Names.Count, asNames.Count);

            for (int i = 0; i < len; i++)
            {
                var nameNode = asNames[i] ?? node.Names[i];
                var impName  = node.Names[i].Name;
                var newName  = asNames[i] != null ? asNames[i].Name : null;

                if (string.IsNullOrEmpty(impName))
                {
                    // incomplete import statement
                    continue;
                }
                else if (impName == "*")
                {
                    // Handle "import *"
                    if (userMod != null)
                    {
                        userMod.Imported(_unit);

                        foreach (var varName in userMod.GetModuleMemberNames(GlobalScope.InterpreterContext))
                        {
                            if (!varName.StartsWithOrdinal("_"))
                            {
                                fullImpName[fullImpName.Length - 1] = varName;
                                AssignImportedMember(nameNode, userMod, fullImpName, varName);
                            }
                        }
                    }
                }
                else
                {
                    userMod.Imported(_unit);
                    fullImpName[fullImpName.Length - 1] = impName;
                    AssignImportedMember(nameNode, userMod, fullImpName, newName ?? impName);
                }
            }

            return(false);
        }
예제 #12
0
        public override bool Walk(FromImportStatement node)
        {
            var modName = node.Root.MakeString();

            if (modName == "__future__")
            {
                return(false);
            }

            if (node.Names == null)
            {
                return(false);
            }

            bool onlyImportModules = modName.EndsWith(".");

            var mod = new AstNestedPythonModule(
                _interpreter,
                modName,
                PythonAnalyzer.ResolvePotentialModuleNames(_module.Name, _filePath, modName, true).ToArray()
                );
            var ctxt = _interpreter.CreateModuleContext();

            mod.Imported(ctxt);
            // Ensure child modules have been loaded
            mod.GetChildrenModules();

            try {
                for (int i = 0; i < node.Names.Count; ++i)
                {
                    if (!onlyImportModules)
                    {
                        if (node.Names[i].Name == "*")
                        {
                            foreach (var member in mod.GetMemberNames(ctxt))
                            {
                                var mem = mod.GetMember(ctxt, member) ?? new AstPythonConstant(
                                    _interpreter.GetBuiltinType(BuiltinTypeId.Unknown),
                                    mod.Locations.ToArray()
                                    );
                                _scope.SetInScope(member, mem);
                                (mem as IPythonModule)?.Imported(ctxt);
                            }
                            continue;
                        }
                        var n = node.AsNames?[i] ?? node.Names[i];
                        if (n != null)
                        {
                            var mem = mod.GetMember(ctxt, node.Names[i].Name) ?? new AstPythonConstant(
                                _interpreter.GetBuiltinType(BuiltinTypeId.Unknown),
                                GetLoc(n)
                                );
                            _scope.SetInScope(n.Name, mem);
                            (mem as IPythonModule)?.Imported(ctxt);
                        }
                    }
                }
            } catch (IndexOutOfRangeException) {
            }
            return(false);
        }
 public override void PostWalk(FromImportStatement node)
 {
     Trace.Assert(!node.IsFromFuture);
     ImportedModules.Add(string.Join('.', node.Root.Names));
 }
예제 #14
0
 // FromImportStatement
 public virtual bool Walk(FromImportStatement node) { return true; }
예제 #15
0
        public static void AddImport(
            IServiceProvider serviceProvider,
            ITextBuffer buffer,
            ITextView view,
            string fromModule,
            string name
            )
        {
            var analyzer = buffer.GetAnalyzer(serviceProvider);
            var curAst   = analyzer.ParseSnapshot(buffer.CurrentSnapshot);

            var       suiteBody    = curAst.Body as SuiteStatement;
            Statement insertBefore = null;

            if (suiteBody != null)
            {
                bool firstStatement = true;

                foreach (var statement in suiteBody.Statements)
                {
                    if (firstStatement && IsDocString(statement as ExpressionStatement))
                    {
                        // doc string, ignore this
                        firstStatement = false;
                        continue;
                    }

                    firstStatement = false;

                    // __future__ imports go first
                    if (fromModule == null || fromModule != "__future__")
                    {
                        if (statement is ImportStatement)
                        {
                            // we insert after this
                            continue;
                        }
                        else if (statement is FromImportStatement)
                        {
                            // we might update this, we might insert after
                            FromImportStatement fromImport = statement as FromImportStatement;
                            if (fromImport.Root.MakeString() == fromModule)
                            {
                                // update the existing from ... import statement to include the new name.
                                UpdateFromImport(curAst, buffer, fromImport, name);
                                return;
                            }
                            continue;
                        }
                    }

                    // this isn't an import, we insert before this statement
                    insertBefore = statement;
                    break;
                }
            }

            int start;

            if (insertBefore != null)
            {
                var location = insertBefore.GetStart(curAst);

                var point = buffer.CurrentSnapshot.GetLineFromLineNumber(location.Line - 1).Start;
                // the span starts after any whitespace, so walk backup and see if we should skip some lines
                if (point.Position != 0)
                {
                    var prevPoint = point.Subtract(1);

                    //  walk past all the previous lines
                    var classifier = buffer.GetPythonClassifier();

                    bool moved = false;
                    while (prevPoint.Position != 0 &&
                           (char.IsWhiteSpace(prevPoint.GetChar()) || IsCommentChar(prevPoint, classifier)))
                    {
                        prevPoint = prevPoint.Subtract(1);
                        moved     = true;
                    }
                    prevPoint = prevPoint.Add(1);

                    // then walk forward one line
                    if (moved)
                    {
                        int lineNum = prevPoint.GetContainingLine().LineNumber;
                        do
                        {
                            prevPoint = prevPoint.Add(1);
                        } while (lineNum == prevPoint.GetContainingLine().LineNumber);
                    }

                    point = prevPoint;
                }
                start = point.Position;
            }
            else
            {
                start = 0;
            }

            buffer.Insert(start, MakeImportCode(fromModule, name) + view.Options.GetNewLineCharacter());
        }
예제 #16
0
 // FromImportStatement
 public override bool Walk(FromImportStatement node) { return false; }
예제 #17
0
        public override bool Walk(FromImportStatement node)
        {
            var             mods = ProjectState.GetReflectedNamespaces(node.Root.Names, true);
            ModuleReference moduleRef;
            Namespace       userMod = null;
            var             modName = node.Root.MakeString();

            if (ProjectState.Modules.TryGetValue(modName, out moduleRef))
            {
                userMod = moduleRef.Module;
                if (userMod == null)
                {
                    moduleRef.References.Add(_unit);
                }
            }
            else
            {
                moduleRef = ProjectState.Modules[modName] = new ModuleReference();
                if (moduleRef.References == null)
                {
                    moduleRef.References = new HashSet <AnalysisUnit>();
                }
                moduleRef.References.Add(_unit);
            }

            var asNames = node.AsNames ?? node.Names;
            var impInfo = new ImportInfo(node.Root.MakeString(), node.Span);

            GlobalScope.Imports[node] = impInfo;

            int len = Math.Min(node.Names.Count, asNames.Count);

            for (int i = 0; i < len; i++)
            {
                var impName = node.Names[i];
                var newName = asNames[i];

                if (impName == null)
                {
                    // incomplete import statement
                    continue;
                }
                else if (impName == "*")
                {
                    // Handle "import *"
                    if (userMod != null)
                    {
                        foreach (var varName in GetModuleKeys(userMod))
                        {
                            WalkFromImportWorker(node, userMod, mods, varName, null);
                        }
                    }
                    if (mods != null)
                    {
                        foreach (var mod in mods)
                        {
                            foreach (var name in Utils.DirHelper(mod, true))
                            {
                                WalkFromImportWorker(node, null, mods, name, null);
                            }
                        }
                    }
                }
                else
                {
                    WalkFromImportWorker(node, userMod, mods, impName, newName);
                }
            }

            return(true);
        }
예제 #18
0
 // FromImportStatement
 public override bool Walk(FromImportStatement node)
 {
     return(ShouldWalkWorker(node));
 }
예제 #19
0
        public override bool Walk(FromImportStatement node)
        {
            UpdateLineInfo(node);

            return(base.Walk(node));
        }
예제 #20
0
 public override bool Walk(FromImportStatement node)
 {
     AddTagIfNecessary(node);
     return(base.Walk(node));
 }
 public override Task <bool> WalkAsync(FromImportStatement node, CancellationToken cancellationToken = default)
 => FromImportHandler.HandleFromImportAsync(node, cancellationToken);
        private Reference HandleFromImport(IDocumentAnalysis analysis, SourceLocation location, FromImportStatement statement, Node expr, out ILocatedMember definingMember)
        {
            definingMember = null;

            var           mres    = analysis.Document.Interpreter.ModuleResolution;
            var           imports = mres.CurrentPathResolver.FindImports(analysis.Document.FilePath, statement);
            IPythonModule module  = null;

            switch (imports)
            {
            case ModuleImport moduleImport:
                module = mres.GetImportedModule(moduleImport.FullName);
                break;

            case ImplicitPackageImport packageImport:
                module = mres.GetImportedModule(packageImport.FullName);
                break;
            }

            // Are we in the module name (i.e. A in 'from A import B')?
            var locationIndex = location.ToIndex(analysis.Ast);

            if (statement.Root.StartIndex <= locationIndex && locationIndex <= statement.Root.EndIndex)
            {
                definingMember = module;
                return(module != null
                    ? new Reference {
                    range = default, uri = CanNavigateToModule(module) ? module.Uri : null
예제 #23
0
 // FromImportStatement
 public override bool Walk(FromImportStatement node)
 {
     return(Contains(node));
 }
예제 #24
0
 public UpdatedFromImportStatement(FromImportStatement fromImport)
 {
     _fromImport = fromImport;
 }
예제 #25
0
        public override bool Walk(FromImportStatement node)
        {
            var modName = node.Root.MakeString();

            if (modName == "__future__")
            {
                return(false);
            }

            if (node.Names == null)
            {
                return(false);
            }

            var mod = new AstNestedPythonModule(
                _interpreter,
                modName,
                PythonAnalyzer.ResolvePotentialModuleNames(_module.Name, _filePath, modName, true).ToArray()
                );

            foreach (var name in GetImportNames(node.Names, node.AsNames))
            {
                if (name.Key == "*")
                {
                    mod.Imported(_scope.Context);
                    // Ensure child modules have been loaded
                    mod.GetChildrenModules();
                    foreach (var member in mod.GetMemberNames(_scope.Context))
                    {
                        var mem = mod.GetMember(_scope.Context, member) ??
                                  new AstPythonConstant(_unknownType, mod.Locations.ToArray());
                        if (mem.MemberType == PythonMemberType.Unknown && WarnAboutUndefinedValues)
                        {
                            _log?.Log(TraceLevel.Warning, "UndefinedImport", modName, name);
                        }
                        _scope.SetInScope(member, mem);
                        (mem as IPythonModule)?.Imported(_scope.Context);
                    }
                }
                else
                {
                    IMember mem;
                    if (mod.IsLoaded)
                    {
                        mem = mod.GetMember(_scope.Context, name.Key) ??
                              new AstPythonConstant(_unknownType, GetLoc(name.Value));
                        if (mem.MemberType == PythonMemberType.Unknown && WarnAboutUndefinedValues)
                        {
                            _log?.Log(TraceLevel.Warning, "UndefinedImport", modName, name);
                        }
                        (mem as IPythonModule)?.Imported(_scope.Context);
                    }
                    else
                    {
                        mem = new AstNestedPythonModuleMember(name.Key, mod, _scope.Context, GetLoc(name.Value));
                    }
                    _scope.SetInScope(name.Value.Name, mem);
                }
            }

            return(false);
        }
 // FromImportStatement
 public virtual bool Walk(FromImportStatement node)
 {
     return(true);
 }
예제 #27
0
 // FromImportStatement
 public override bool Walk(FromImportStatement node)
 {
     return(Location >= node.StartIndex && Location <= node.EndIndex);
 }
 // FromImportStatement
 public override bool Walk(FromImportStatement node)
 {
     return(false);
 }
예제 #29
0
 public FromImportDefinition(FromImportStatement from)
 {
     this.from = from;
 }
예제 #30
0
 // FromImportStatement
 public override bool Walk(FromImportStatement node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
예제 #31
0
 public override bool Walk(FromImportStatement node) => ImportHandler.HandleFromImport(node);
예제 #32
0
 public virtual void PostWalk(FromImportStatement node) { }
예제 #33
0
 public override bool Walk(FromImportStatement node)
 {
     writer.WriteLine("FromImport: " + node.Root.MakeString());
     return(base.Walk(node));
 }
예제 #34
0
 public override void PostWalk(FromImportStatement node) { }
예제 #35
0
 /// <summary>
 /// Extracts actual module names from the 'from import' statement
 /// such as [a, b, c] from 'from . import a, b, c' or [a] from 'from .a import b, c'
 /// </summary>
 /// <param name="entry">Project entry</param>
 /// <param name="node">Import statement node</param>
 /// <returns>Names of modules</returns>
 internal static IEnumerable <string> GetModuleNamesFromImport(IPythonProjectEntry entry, FromImportStatement node)
 => GetModuleNamesFromImport(entry.ModuleName, entry.FilePath, node);