public override bool Walk(FromImportStatement node) { UpdateChildRanges(node); 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]; if (nameNode != null) { if (nameNode.Name == "*") { _scope.ContainsImportStar = true; } else { CreateVariableInDeclaredScope(nameNode); } } } return base.Walk(node); }
public override bool Walk(FromImportStatement node) { UpdateLineInfo(node); return base.Walk(node); }
public UpdatedFromImportStatement(FromImportStatement fromImport) { _fromImport = fromImport; }
public override bool Walk(FromImportStatement node) { if (InTargetScope && !node.IsFromFuture && !(_scopes[_scopes.Count - 1] is ClassDefinition)) { for (int i = 0; i < node.Names.Count; i++) { if (node.Names[i].Name == "*") { // ignore from .. import * continue; } if (node.AsNames != null && node.AsNames[i] != null) { TrackImport(node, node.AsNames[i].Name); } else { TrackImport(node, node.Names[i].Name); } } } return base.Walk(node); }
// 'from' relative_module 'import' identifier ['as' name] (',' identifier ['as' name]) * // 'from' relative_module 'import' '(' identifier ['as' name] (',' identifier ['as' name])* [','] ')' // 'from' module 'import' "*" private FromImportStatement ParseFromImportStmt() { Eat(TokenKind.KeywordFrom); string fromWhiteSpace = _tokenWhiteSpace; var start = GetStart(); ModuleName dname = ParseRelativeModuleName(); bool ateImport = Eat(TokenKind.KeywordImport); string importWhiteSpace = _tokenWhiteSpace; bool ateParen = ateImport && MaybeEat(TokenKind.LeftParenthesis); string parenWhiteSpace = ateParen ? _tokenWhiteSpace : null; NameExpression/*!*/[] names; NameExpression[] asNames; bool fromFuture = false; List<string> namesWhiteSpace = null; if (ateImport) { if (MaybeEat(TokenKind.Multiply)) { if (_langVersion.Is3x() && ((_functions != null && _functions.Count > 0) || _classDepth > 0)) { ReportSyntaxError(start, GetEnd(), "import * only allowed at module level"); } if (_verbatim) { namesWhiteSpace = new List<string>() { _tokenWhiteSpace }; } names = new[] { new NameExpression("*") }; asNames = null; } else { List<NameExpression/*!*/> l = new List<NameExpression>(); List<NameExpression> las = new List<NameExpression>(); ParseAsNameList(l, las, out namesWhiteSpace); names = l.ToArray(); asNames = las.ToArray(); } } else { names = EmptyNames; asNames = EmptyNames; } // Process from __future__ statement if (dname.Names.Count == 1 && dname.Names[0].Name == "__future__") { fromFuture = ProcessFutureStatements(start, names, fromFuture); } bool ateRightParen = false; if (ateParen) { ateRightParen = Eat(TokenKind.RightParenthesis); } FromImportStatement ret = new FromImportStatement(dname, names, asNames, fromFuture, AbsoluteImports); if (_verbatim) { AddPreceedingWhiteSpace(ret, fromWhiteSpace); AddSecondPreceedingWhiteSpace(ret, importWhiteSpace); if (namesWhiteSpace != null) { AddNamesWhiteSpace(ret, namesWhiteSpace.ToArray()); } if (ateParen) { AddThirdPreceedingWhiteSpace(ret, parenWhiteSpace); AddFourthPreceedingWhiteSpace(ret, _tokenWhiteSpace); if (!ateRightParen) { AddErrorMissingCloseGrouping(ret); } } else { AddIsAltForm(ret); } if (!ateImport) { AddErrorIsIncompleteNode(ret); } } ret.SetLoc(start, GetEnd()); return ret; }
/// <summary> /// Returns a new FromImport statement that is identical to this one but has /// removed the specified import statement. Otherwise preserves any attributes /// for the statement. /// /// New in 1.1. /// <param name="ast">The parent AST whose attributes should be updated for the new node.</param> /// <param name="index">The index in Names of the import to be removed.</param> /// </summary> public FromImportStatement RemoveImport(PythonAst ast, int index) { if (index < 0 || index >= Names.Count) { throw new ArgumentOutOfRangeException("index"); } if (ast == null) { throw new ArgumentNullException("ast"); } NameExpression[] names = new NameExpression[Names.Count - 1]; NameExpression[] asNames = AsNames == null ? null : new NameExpression[AsNames.Count - 1]; var asNameWhiteSpace = this.GetNamesWhiteSpace(ast); List <string> newAsNameWhiteSpace = new List <string>(); int importIndex = ImportIndex; int asIndex = 0; for (int i = 0, write = 0; i < Names.Count; i++) { bool includingCurrentName = i != index; // track the white space, this needs to be kept in sync w/ ToCodeString and how the // parser creates the white space. if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (write > 0) { if (includingCurrentName) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } else if (i > 0) { asIndex++; } } if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (includingCurrentName) { if (newAsNameWhiteSpace.Count == 0) { // no matter what we want the 1st entry to have the whitespace after the import keyword newAsNameWhiteSpace.Add(asNameWhiteSpace[0]); asIndex++; } else { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } } else { asIndex++; } } if (includingCurrentName) { names[write] = Names[i]; if (AsNames != null) { asNames[write] = AsNames[i]; } write++; } if (AsNames != null && AsNames[i] != null) { if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (i != index) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } if (AsNames[i].Name.Length != 0) { if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (i != index) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } } else { asIndex++; } } } if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { // trailing comma newAsNameWhiteSpace.Add(asNameWhiteSpace[asNameWhiteSpace.Length - 1]); } var res = new FromImportStatement(Root, names, asNames, IsFromFuture, ForceAbsolute, importIndex); ast.CopyAttributes(this, res); ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray()); return(res); }
public override bool Walk(FromImportStatement node) { var vars = node.Variables; var refs = node.GetReferences(_root); if (refs != null) { // from .. import * will have null refs for (int i = 0; i < vars.Length; i++) { if (vars[i] != null) { _allWrites.Add(refs[i]); _allWrittenVariables.Add(vars[i]); } } } return base.Walk(node); }
private static AP.ChangeInfo UpdateFromImport( PythonAst curAst, FromImportStatement fromImport, string name ) { NameExpression[] names = new NameExpression[fromImport.Names.Count + 1]; NameExpression[] asNames = fromImport.AsNames == null ? null : new NameExpression[fromImport.AsNames.Count + 1]; NameExpression newName = new NameExpression(name); for (int i = 0; i < fromImport.Names.Count; i++) { names[i] = fromImport.Names[i]; } names[fromImport.Names.Count] = newName; if (asNames != null) { for (int i = 0; i < fromImport.AsNames.Count; i++) { asNames[i] = fromImport.AsNames[i]; } } var newImport = new FromImportStatement((ModuleName)fromImport.Root, names, asNames, fromImport.IsFromFuture, fromImport.ForceAbsolute); curAst.CopyAttributes(fromImport, newImport); var newCode = newImport.ToCodeString(curAst); var span = fromImport.GetSpan(curAst); int leadingWhiteSpaceLength = (fromImport.GetLeadingWhiteSpace(curAst) ?? "").Length; return new AP.ChangeInfo() { start = span.Start.Index - leadingWhiteSpaceLength, length = span.Length + leadingWhiteSpaceLength, newText = newCode }; }
// FromImportStmt public override bool Walk(FromImportStatement node) { if (node.Names.Count != 1 || node.Names[0].Name != "*") { for (int i = 0; i < node.Names.Count; i++) { Define(node.AsNames[i] != null ? node.AsNames[i].Name : node.Names[i].Name); } } return true; }
public override bool Walk(FromImportStatement node) { if (node.Names.Count == 1 && node.Names[0].Name == "*") { ContainsImportStar = true; } return base.Walk(node); }
public override void PostWalk(FromImportStatement node) { PostWalkWorker(node); }
// FromImportStatement public override bool Walk(FromImportStatement node) { return ShouldWalkWorker(node); }
/// <summary> /// Returns a new FromImport statement that is identical to this one but has /// removed the specified import statement. Otherwise preserves any attributes /// for the statement. /// /// New in 1.1. /// <param name="ast">The parent AST whose attributes should be updated for the new node.</param> /// <param name="index">The index in Names of the import to be removed.</param> /// </summary> public FromImportStatement RemoveImport(PythonAst ast, int index) { if (index < 0 || index >= _names.Length) { throw new ArgumentOutOfRangeException("index"); } if (ast == null) { throw new ArgumentNullException("ast"); } NameExpression[] names = new NameExpression[_names.Length - 1]; NameExpression[] asNames = _asNames == null ? null : new NameExpression[_asNames.Length - 1]; var asNameWhiteSpace = this.GetNamesWhiteSpace(ast); List<string> newAsNameWhiteSpace = new List<string>(); int asIndex = 0; for (int i = 0, write = 0; i < _names.Length; i++) { bool includingCurrentName = i != index; // track the white space, this needs to be kept in sync w/ ToCodeString and how the // parser creates the white space. if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (write > 0) { if (includingCurrentName) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } else if (i > 0) { asIndex++; } } if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (includingCurrentName) { if (newAsNameWhiteSpace.Count == 0) { // no matter what we want the 1st entry to have the whitespace after the import keyword newAsNameWhiteSpace.Add(asNameWhiteSpace[0]); asIndex++; } else { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } } else { asIndex++; } } if (includingCurrentName) { names[write] = _names[i]; if (_asNames != null) { asNames[write] = _asNames[i]; } write++; } if (AsNames != null && AsNames[i] != null) { if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (i != index) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } if (_asNames[i].Name.Length != 0) { if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { if (i != index) { newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]); } else { asIndex++; } } } else { asIndex++; } } } if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length) { // trailing comma newAsNameWhiteSpace.Add(asNameWhiteSpace[asNameWhiteSpace.Length - 1]); } var res = new FromImportStatement(_root, names, asNames, IsFromFuture, ForceAbsolute); ast.CopyAttributes(this, res); ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray()); return res; }
// FromImportStatement public override bool Walk(FromImportStatement node) { if (node.Names.Count != 1 || node.Names[0].Name !="*") { PythonVariable[] variables = new PythonVariable[node.Names.Count]; PythonReference[] references = null; if (_bindRefs) { references = new PythonReference[node.Names.Count]; } for (int i = 0; i < node.Names.Count; i++) { variables[i] = DefineName(node.AsNames[i] != null ? node.AsNames[i].Name : node.Names[i].Name); if (references != null) { references[i] = Reference(variables[i].Name); } } node.Variables = variables; node.AddVariableReference(_ast, _bindRefs, references); } else { Debug.Assert(_currentScope != null); _currentScope.ContainsImportStar = true; _currentScope.NeedsLocalsDictionary = true; _currentScope.HasLateBoundVariableSets = true; } return true; }
public override bool Walk(FromImportStatement node) { var m = _scope.Peek(); if (node.Root.MakeString() == "__future__") { return false; } if (m != null && node.Names != null) { try { for (int i = 0; i < node.Names.Count; ++i) { var n = node.AsNames?[i] ?? node.Names[i]; if (n != null) { m[n.Name] = new AstPythonConstant( _interpreter.GetBuiltinType(BuiltinTypeId.Unknown), GetLoc(n) ); } } } catch (IndexOutOfRangeException) { } } return false; }
public override bool Walk(FromImportStatement node) { Debug.Assert(_head != null); if (node.Root != null) { foreach (var name in node.Root.Names) { if (name != null && !string.IsNullOrEmpty(name.Name)) { AddSpan(Tuple.Create(name.Name, Span.FromBounds(name.StartIndex, name.EndIndex)), PythonPredefinedClassificationTypeNames.Module); } } } if (node.Names != null) { foreach (var name in node.Names) { if (name != null && !string.IsNullOrEmpty(name.Name)) { _head.Names.Add(Tuple.Create(name.Name, Span.FromBounds(name.StartIndex, name.EndIndex))); } } } return base.Walk(node); }
private static void UpdateFromImport( PythonAst curAst, ITextBuffer buffer, FromImportStatement fromImport, string name ) { NameExpression[] names = new NameExpression[fromImport.Names.Count + 1]; NameExpression[] asNames = fromImport.AsNames == null ? null : new NameExpression[fromImport.AsNames.Count + 1]; NameExpression newName = new NameExpression(name); for (int i = 0; i < fromImport.Names.Count; i++) { names[i] = fromImport.Names[i]; } names[fromImport.Names.Count] = newName; if (asNames != null) { for (int i = 0; i < fromImport.AsNames.Count; i++) { asNames[i] = fromImport.AsNames[i]; } } var newImport = new FromImportStatement((ModuleName)fromImport.Root, names, asNames, fromImport.IsFromFuture, fromImport.ForceAbsolute); curAst.CopyAttributes(fromImport, newImport); var newCode = newImport.ToCodeString(curAst); var span = fromImport.GetSpan(curAst); int leadingWhiteSpaceLength = (fromImport.GetLeadingWhiteSpace(curAst) ?? "").Length; using (var edit = buffer.CreateEdit()) { edit.Delete(span.Start.Index - leadingWhiteSpaceLength, span.Length + leadingWhiteSpaceLength); edit.Insert(span.Start.Index, newCode); edit.Apply(); } }
public override bool Walk(FromImportStatement node) { var name = node.Root.MakeString(); if (!_analyzer.IsModuleResolved(_entry, name, node.ForceAbsolute)) { Imports.Add(Tuple.Create(name, node.Root)); } return base.Walk(node); }
public RemovedFromImportStatement(FromImportStatement fromImport) { _fromImport = fromImport; }
public override bool Walk(FromImportStatement node) { var vars = node.Variables; for (int i = 0; i < vars.Length; i++) { if (vars[i] != null) { _names.Add(vars[i].Name); } } return base.Walk(node); }
public override bool Walk(FromImportStatement node) { AddTagIfNecessary(node); return base.Walk(node); }