public void Visit(PyAst.FromImportStatement node) { var aliasPart = node.AsNames is null ? "" : $" as {node.AsNames.Single()}"; var isUsingStatic = node.Root.Names.Contains(CSharpToPythonConvert.UsingStaticMagicString); var modName = FormatDottedName( node.Root, isUsingStatic ? new[] { CSharpToPythonConvert.UsingStaticMagicString } : Array.Empty <string>() ); var usingStaticWarningComment = isUsingStatic ? " #ERROR: Was using static directive" : ""; AppendLineWithIndentation($"from {modName} import *{aliasPart}{usingStaticWarningComment}"); }
public PythonFromImport(IProjectContent projectContent, FromImportStatement fromImport) : base(projectContent) { this.fromImport = fromImport; }
public override void PostWalk(FromImportStatement node) { CommonPostWalk(node); }
public ImportFrom(FromImportStatement stmt) : this() { _module = stmt.Root.MakeString(); _module = string.IsNullOrEmpty(_module) ? null : _module; _names = ConvertAliases(stmt.Names, stmt.AsNames); if (stmt.Root is RelativeModuleName) _level = ((RelativeModuleName)stmt.Root).DotCount; }
// FromImportStatement public bool Walk(FromImportStatement node) { return Process(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); SourceLocation start = GetStart(); ModuleName dname = ParseRelativeModuleName(); Eat(TokenKind.KeywordImport); bool ateParen = MaybeEat(TokenKind.LeftParenthesis); SymbolId[] names; SymbolId[] asNames; bool fromFuture = false; if (MaybeEat(TokenKind.Multiply)) { names = FromImportStatement.Star; asNames = null; if (dname is RelativeModuleName) { ReportSyntaxError("'import *' not allowed with 'from .'"); } } else { List<SymbolId> l = new List<SymbolId>(); List<SymbolId> las = new List<SymbolId>(); if (MaybeEat(TokenKind.LeftParenthesis)) { ParseAsNameList(l, las); Eat(TokenKind.RightParenthesis); } else { ParseAsNameList(l, las); } names = l.ToArray(); asNames = las.ToArray(); } // Process from __future__ statement if (dname.Names.Count == 1 && dname.Names[0] == Symbols.Future) { if (!_fromFutureAllowed) { ReportSyntaxError(IronPython.Resources.MisplacedFuture); } if (names == FromImportStatement.Star) { ReportSyntaxError(IronPython.Resources.NoFutureStar); } fromFuture = true; foreach (SymbolId name in names) { if (name == Symbols.Division) { _languageFeatures |= PythonLanguageFeatures.TrueDivision; } else if (name == Symbols.WithStmt) { _languageFeatures |= PythonLanguageFeatures.AllowWithStatement; } else if (name == Symbols.AbsoluteImport) { _languageFeatures |= PythonLanguageFeatures.AbsoluteImports; } else if (name == Symbols.PrintFunction && Python26) { _languageFeatures |= PythonLanguageFeatures.PrintFunction; _tokenizer.PrintFunction = true; } else if (name == Symbols.UnicodeLiterals && Python26) { // nop for us, just ignore it... } else if (name == Symbols.NestedScopes) { } else if (name == Symbols.Generators) { } else { string strName = SymbolTable.IdToString(name); fromFuture = false; if (strName != "braces") { ReportSyntaxError(IronPython.Resources.UnknownFutureFeature + strName); } else { // match CPython error message ReportSyntaxError(IronPython.Resources.NotAChance); } } } } if (ateParen) { Eat(TokenKind.RightParenthesis); } FromImportStatement ret = new FromImportStatement(dname, names, asNames, fromFuture, AbsoluteImports); ret.SetLoc(start, GetEnd()); return ret; }
public void FromSystemImportStatementFollowedByEmptySpaceHasModuleNameOfSystem() { string text = "from System import "; fromStatement = ParseStatement(text); Assert.AreEqual("System", fromStatement.Root.MakeString()); }
// FromImportStmt public override bool Walk(FromImportStatement node) { if (node.Names != FromImportStatement.Star) { for (int i = 0; i < node.Names.Count; i++) { Define(node.AsNames[i] != null ? node.AsNames[i] : node.Names[i]); } } return true; }
public virtual void PostWalk(FromImportStatement node) { }
public override bool Walk(FromImportStatement node) { Emit(node); return false; }
// FromImportStatement public virtual bool Walk(FromImportStatement node) { return true; }
// FromImportStmt public override bool Walk(FromImportStatement node) { if (node.Names != FromImportStatement.Star) { for (int i = 0; i < node.Names.Count; i++) { Define(node.AsNames[i] != SymbolTable.Empty ? node.AsNames[i] : node.Names[i]); } } else { Debug.Assert(current != null); current.ContainsImportStar = true; } return true; }
//| 'from' dotted_name 'import' ('*' | as_name_list | '(' as_name_list ')' ) private FromImportStatement ParseFromImportStmt() { Eat(TokenKind.KeywordFrom); Location start = GetStart(); DottedName dname = ParseDottedName(); Eat(TokenKind.KeywordImport); IList<SymbolId> names; IList<SymbolId> asNames; bool fromFuture = false; if (MaybeEat(TokenKind.Multiply)) { names = FromImportStatement.Star; asNames = null; } else { List<SymbolId> l = new List<SymbolId>(); List<SymbolId> las = new List<SymbolId>(); if (MaybeEat(TokenKind.LeftParenthesis)) { ParseAsNameList(l, las); Eat(TokenKind.RightParenthesis); } else { ParseAsNameList(l, las); } names = l.ToArray(); asNames = las.ToArray(); } // Process from __future__ statement if (dname.Names.Count == 1 && dname.Names[0] == SymbolTable.Future) { if (!fromFutureAllowed) { ReportSyntaxError("from __future__ imports must occur at the beginning of the file"); } if (names == FromImportStatement.Star) { ReportSyntaxError("future statement does not support import *"); } fromFuture = true; foreach (SymbolId name in names) { if (name == SymbolTable.Division) { context.TrueDivision = true; } else if (Options.Python25 && name == SymbolTable.WithStmt) { context.AllowWithStatement = true; } else if (name == SymbolTable.NestedScopes) { } else if (name == SymbolTable.Generators) { } else { fromFuture = false; ReportSyntaxError(string.Format("future feature is not defined: {0}", name.GetString())); } } } FromImportStatement ret = new FromImportStatement(dname, names, asNames, fromFuture); ret.SetLoc(GetExternal(), start, GetEnd()); return ret; }
public override bool Walk(FromImportStatement node) { PythonFromImport import = new PythonFromImport(compilationUnit.ProjectContent, node); compilationUnit.UsingScope.Usings.Add(import); return false; }
public void FromSystemStatementWithNoImportHasModuleNameOfSystem() { string text = "from System"; fromStatement = ParseStatement(text); Assert.AreEqual("System", fromStatement.Root.MakeString()); }
private CodeGen CompileModuleInit(CompilerContext context, GlobalSuite gs, TypeGen tg, string moduleName) { CodeGen init; if (!AutoImportAll) { init = OutputGenerator.GenerateModuleInitialize(context, gs, tg); } else { // auto-import all compiled modules, useful for CodeDom scenarios. init = OutputGenerator.GenerateModuleInitialize(context, gs, tg, staticTypes, delegate(CodeGen cg) { Location dummyLocation = new Location(1, 1); for (int i = 0; i < sourceFiles.Count; i++) { string otherModName = GetModuleFromFilename(sourceFiles[i]); if (otherModName == moduleName) continue; FromImportStatement stmt = new FromImportStatement( new DottedName(new SymbolId[] { SymbolTable.StringToId(otherModName) }), FromImportStatement.Star, null); stmt.Start = dummyLocation; stmt.End = dummyLocation; stmt.Emit(cg); } // Import the first part of all namespaces in all referenced assemblies // First, determine the set of unique such prefixes Dictionary<string, object> nsPrefixes = new Dictionary<string, object>(); foreach (string name in ReferencedAssemblies) { Assembly a = LoadAssembly(name); foreach (Type t in a.GetTypes()) { // We only care about public types if (!t.IsPublic) continue; // Ignore types that don't have a namespace if (t.Namespace == null) continue; string nsPrefix = t.Namespace.Split('.')[0]; nsPrefixes[nsPrefix] = null; } } // Import all the uniquer prefixes we found foreach (string nsPrefix in nsPrefixes.Keys) { SymbolId symbolId = SymbolTable.StringToId(nsPrefix); cg.Names.CreateGlobalSlot(symbolId); DottedName dottedName = new DottedName(new SymbolId[] { symbolId }); ImportStatement importStmt = new ImportStatement( new DottedName[] { dottedName }, new SymbolId[] { SymbolTable.Empty }); importStmt.Start = dummyLocation; importStmt.End = dummyLocation; importStmt.Emit(cg); } }); } return init; }
public void FromStatementFollowedBySpaceCharButNoModuleNameHasModuleNameOfEmptyString() { string text = "from "; fromStatement = ParseStatement(text); Assert.AreEqual(String.Empty, fromStatement.Root.MakeString()); }
public void PostWalk(FromImportStatement node) { PostProcess(node); }
public void FromSystemImportStatementFollowedByIdentifierAsNameHasIdentifierAsNameInAsNamesCollection() { string text = "from System import abc as def"; fromStatement = ParseStatement(text); Assert.AreEqual("def", fromStatement.AsNames[0]); }
// FromImportStatement public override bool Walk(FromImportStatement node) { if (node.Names != FromImportStatement.Star) { for (int i = 0; i < node.Names.Count; i++) { SymbolId name = node.AsNames[i] != SymbolTable.Empty ? node.AsNames[i] : node.Names[i]; Define(name, new FromImportDefinition(node)); } } return true; }
public override bool Walk(FromImportStatement node) { var container = containers.Peek (); if (!container.SupportsFromStatements) return base.Walk (node); var fromImport = new PythonFromImport () { ModuleName = node.Root.MakeString (), Region = GetDomRegion (node) }; // even if '*' is present, we may get an alias for a member // (using 'as') bool importAll = node.Names.Where (name => name == "*").Count () > 0; var names = new List<PythonNameReference> (); for (int i = 0; i < node.Names.Count; i++) { var name = node.Names [i]; var asname = node.AsNames == null ? null : node.AsNames [i]; // Discard unused data if (importAll && (String.IsNullOrEmpty (asname) || name == "*")) continue; var nameRef = new PythonNameReference () { Name = node.Names [i], AsName = node.AsNames == null ? null : node.AsNames [i] }; names.Add (nameRef); } fromImport.Names = names; fromImport.ImportAll = importAll; container.FromImports.Add (fromImport); return base.Walk (node); }
public override bool Walk(FromImportStatement node) { CommonWalk(node); return true; }
// FromImportStatement public override bool Walk(FromImportStatement node) { if (node.Names != FromImportStatement.Star) { PythonVariable[] variables = new PythonVariable[node.Names.Count]; for (int i = 0; i < node.Names.Count; i++) { SymbolId name = node.AsNames[i] != SymbolId.Empty ? node.AsNames[i] : node.Names[i]; variables[i] = DefineName(name); } node.Variables = variables; } else { Debug.Assert(_currentScope != null); _currentScope.ContainsImportStar = true; _currentScope.NeedsLocalsDictionary = true; } return true; }
// FromImportStatement public override bool Walk(FromImportStatement node) { node.Parent = _currentScope; if (node.Names != FromImportStatement.Star) { PythonVariable[] variables = new PythonVariable[node.Names.Count]; node.Root.Parent = _currentScope; for (int i = 0; i < node.Names.Count; i++) { string name = node.AsNames[i] != null ? node.AsNames[i] : node.Names[i]; variables[i] = DefineName(name); } node.Variables = variables; } else { Debug.Assert(_currentScope != null); _currentScope.ContainsImportStar = true; _currentScope.NeedsLocalsDictionary = true; _currentScope.HasLateBoundVariableSets = true; } return true; }
public FromImportDefinition(FromImportStatement from) { this.from = from; }
// '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); var start = GetStart(); ModuleName dname = ParseRelativeModuleName(); Eat(TokenKind.KeywordImport); bool ateParen = MaybeEat(TokenKind.LeftParenthesis); string[] names; string[] asNames; bool fromFuture = false; if (MaybeEat(TokenKind.Multiply)) { names = (string[])FromImportStatement.Star; asNames = null; } else { List<string> l = new List<string>(); List<string> las = new List<string>(); if (MaybeEat(TokenKind.LeftParenthesis)) { ParseAsNameList(l, las); Eat(TokenKind.RightParenthesis); } else { ParseAsNameList(l, las); } names = l.ToArray(); asNames = las.ToArray(); } // Process from __future__ statement if (dname.Names.Count == 1 && dname.Names[0] == "__future__") { if (!_fromFutureAllowed) { ReportSyntaxError(IronPython.Resources.MisplacedFuture); } if (names == FromImportStatement.Star) { ReportSyntaxError(IronPython.Resources.NoFutureStar); } fromFuture = true; foreach (string name in names) { if (name == "division") { _languageFeatures |= ModuleOptions.TrueDivision; } else if (name == "with_statement") { _languageFeatures |= ModuleOptions.WithStatement; } else if (name == "absolute_import") { _languageFeatures |= ModuleOptions.AbsoluteImports; } else if (name == "print_function") { _languageFeatures |= ModuleOptions.PrintFunction; _tokenizer.PrintFunction = true; } else if (name == "unicode_literals") { _tokenizer.UnicodeLiterals = true; _languageFeatures |= ModuleOptions.UnicodeLiterals; } else if (name == "nested_scopes") { } else if (name == "generators") { } else { string strName = name; fromFuture = false; if (strName != "braces") { ReportSyntaxError(IronPython.Resources.UnknownFutureFeature + strName); } else { // match CPython error message ReportSyntaxError(IronPython.Resources.NotAChance); } } } } if (ateParen) { Eat(TokenKind.RightParenthesis); } FromImportStatement ret = new FromImportStatement(dname, (string[])names, asNames, fromFuture, AbsoluteImports); ret.SetLoc(_globalParent, start, GetEnd()); return ret; }
public override bool Walk(FromImportStatement node) { writer.WriteLine("FromImport: " + node.Root.MakeString()); return base.Walk(node); }