mirrors/RustPython-Parser
1
0
Fork 0
mirror of https://github.com/RustPython/Parser.git synced 2025-07-12 07:35:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Import all from_list in one __import__ call

Browse source
This commit is contained in:
Aviv Palivoda 2019-06-13 20:41:37 +03:00
parent e85f8b18df
commit a932b729d8
3 changed files with 55 additions and 25 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/bytecode.rs
View file

@ -50,7 +50,7 @@ pub enum NameScope {
pub enum Instruction { pub enum Instruction {
Import { Import {
name: String, name: String,
symbol: Option<String>, symbols: Vec<String>,
}, },
ImportStar { ImportStar {
name: String, name: String,
@ -330,7 +330,7 @@ impl Instruction {
} }
match self { match self {
Import { name, symbol } => w!(Import, name, format!("{:?}", symbol)), Import { name, symbols } => w!(Import, name, format!("{:?}", symbols)),
ImportStar { name } => w!(ImportStar, name), ImportStar { name } => w!(ImportStar, name),
LoadName { name, scope } => w!(LoadName, name, format!("{:?}", scope)), LoadName { name, scope } => w!(LoadName, name, format!("{:?}", scope)),
StoreName { name, scope } => w!(StoreName, name, format!("{:?}", scope)), StoreName { name, scope } => w!(StoreName, name, format!("{:?}", scope)),

56
src/compile.rs
View file

@ -250,29 +250,51 @@ impl Compiler {
ast::Statement::Import { import_parts } => { ast::Statement::Import { import_parts } => {
for ast::SingleImport { for ast::SingleImport {
module, module,
symbol, symbols,
alias, alias,
} in import_parts } in import_parts
{ {
match symbol { if let Some(alias) = alias {
Some(name) if name == "*" => { self.emit(Instruction::Import {
self.emit(Instruction::ImportStar { name: module.clone(),
name: module.clone(), symbols: vec![],
}); });
} self.store_name(&alias);
_ => { } else {
if symbols.is_empty() {
self.emit(Instruction::Import { self.emit(Instruction::Import {
name: module.clone(), name: module.clone(),
symbol: symbol.clone(), symbols: vec![],
}); });
let name = match alias { self.store_name(&module.clone());
Some(alias) => alias.clone(), } else {
None => match symbol { let mut import_star = false;
Some(symbol) => symbol.clone(), let mut symbols_strings = vec![];
None => module.clone(), let mut names = vec![];
}, for ast::ImportSymbol { symbol, alias } in symbols {
}; if symbol == "*" {
self.store_name(&name); import_star = true;
}
symbols_strings.push(symbol.to_string());
names.insert(
0,
match alias {
Some(alias) => alias,
None => symbol,
},
);
}
if import_star {
self.emit(Instruction::ImportStar {
name: module.clone(),
});
} else {
self.emit(Instruction::Import {
name: module.clone(),
symbols: symbols_strings,
});
names.iter().for_each(|name| self.store_name(&name));
}
} }
} }
} }

20
src/symboltable.rs
View file

@ -300,14 +300,22 @@ impl SymbolTableBuilder {
for part in import_parts { for part in import_parts {
if let Some(alias) = &part.alias { if let Some(alias) = &part.alias {
// `import mymodule as myalias` // `import mymodule as myalias`
// `from mymodule import myimportname as myalias`
self.register_name(alias, SymbolRole::Assigned)?; self.register_name(alias, SymbolRole::Assigned)?;
} else if let Some(symbol) = &part.symbol {
// `from mymodule import myimport`
self.register_name(symbol, SymbolRole::Assigned)?;
} else { } else {
// `import module` if part.symbols.is_empty() {
self.register_name(&part.module, SymbolRole::Assigned)?; // `import module`
self.register_name(&part.module, SymbolRole::Assigned)?;
} else {
// `from mymodule import myimport`
for symbol in &part.symbols {
if let Some(alias) = &symbol.alias {
// `from mymodule import myimportname as myalias`
self.register_name(alias, SymbolRole::Assigned)?;
} else {
self.register_name(&symbol.symbol, SymbolRole::Assigned)?;
}
}
}
} }
} }
} }