Import wildcard

compiler/stmt.py

@@ -378,13 +378,15 @@ def visit_Import(self, node):
         self.block.bind_var(self.writer, asname, mod.expr)
 
   def visit_ImportFrom(self, node):
-    # Wildcard imports are not yet supported.
+    self._write_py_context(node.lineno)
     for alias in node.names:
       if alias.name == '*':
-        msg = 'wildcard member import is not implemented: from %s import %s' % (
-            node.module, alias.name)
-        raise util.ParseError(node, msg)
-    self._write_py_context(node.lineno)
+        module_name = node.module
+
+        with self._import(module_name, module_name.count('.')) as module:
+          self.writer.write_checked_call1(
+              'πg.LoadMembers(πF, {})', module.expr)
+        return
     if node.module.startswith(_NATIVE_MODULE_PREFIX):
       values = [alias.name for alias in node.names]
       with self._import_native(node.module, values) as mod:

compiler/stmt_test.py

@@ -366,14 +366,12 @@ def testImportFromFutureParseError(self):
       self.assertRaisesRegexp(util.ParseError, want_regexp,
                               stmt.import_from_future, node)
 
-  def testImportWildcardMemberRaises(self):
-    regexp = r'wildcard member import is not implemented: from foo import *'
-    self.assertRaisesRegexp(util.ParseError, regexp, _ParseAndVisit,
-                            'from foo import *')
-    regexp = (r'wildcard member import is not '
-              r'implemented: from __go__.foo import *')
-    self.assertRaisesRegexp(util.ParseError, regexp, _ParseAndVisit,
-                            'from __go__.foo import *')
+  def testImportWildcard(self):
+    result = _GrumpRun(textwrap.dedent("""\
+        from time import *
+        print sleep"""))
+    self.assertEqual(0, result[0])
+    self.assertIn('<function sleep at', result[1])
 
   def testVisitFuture(self):
     testcases = [

runtime/module.go

@@ -179,6 +179,67 @@ func ImportNativeModule(f *Frame, name string, members map[string]*Object) (*Obj
 	return prev, nil
 }
 
+// LoadMembers scans over all the members in module
+// and populates globals with them, taking __all__ into
+// account.
+func LoadMembers(f *Frame, module *Object) *BaseException {
+	allAttr, raised := GetAttr(f, module, NewStr("__all__"), nil)
+	if raised != nil && !raised.isInstance(AttributeErrorType) {
+		return raised
+	}
+	f.RestoreExc(nil, nil)
+
+	if raised == nil {
+		raised = loadMembersFromIterable(f, module, allAttr, nil)
+		if raised != nil {
+			return raised
+		}
+		return nil
+	}
+
+	// Fall back on __dict__
+	dictAttr, raised := GetAttr(f, module, NewStr("__dict__"), nil)
+	if raised != nil && !raised.isInstance(AttributeErrorType) {
+		return raised
+	}
+	raised = loadMembersFromIterable(f, module, dictAttr, func(key *Object) bool {
+		return strings.HasPrefix(toStrUnsafe(key).value, "_")
+	})
+	if raised != nil {
+		return raised
+	}
+	return nil
+}
+
+func loadMembersFromIterable(f *Frame, module, iterable *Object, filterF func(*Object) bool) *BaseException {
+	iter, raised := Iter(f, iterable)
+	if raised != nil {
+		return raised
+	}
+
+	memberName, raised := Next(f, iter)
+	for ; raised == nil; memberName, raised = Next(f, iter) {
+		member, raised := GetAttr(f, module, toStrUnsafe(memberName), nil)
+		if raised != nil {
+			return raised
+		}
+		if filterF != nil {
+			if filterF(memberName) {
+				continue
+			}
+		}
+		raised = f.Globals().SetItem(f, memberName, member)
+		if raised != nil {
+			return raised
+		}
+	}
+	if !raised.isInstance(StopIterationType) {
+		return raised
+	}
+	f.RestoreExc(nil, nil)
+	return nil
+}
+
 // newModule creates a new Module object with the given fully qualified name
 // (e.g a.b.c) and its corresponding Python filename.
 func newModule(name, filename string) *Module {

runtime/module_test.go

@@ -204,6 +204,54 @@ func TestImportNativeModule(t *testing.T) {
 	}
 }
 
+func TestLoadMembers(t *testing.T) {
+	f := NewRootFrame()
+	var1 := NewStr("var1").ToObject()
+	var2 := NewStr("_var2").ToObject()
+	var3 := NewStr("var3").ToObject()
+	nameAttr := NewStr("__name__").ToObject()
+	allAttr := NewStr("__all__")
+	val1 := NewStr("val1").ToObject()
+	val2 := NewStr("val2").ToObject()
+	val3 := NewStr("val3").ToObject()
+	nameValue := NewStr("foo").ToObject()
+	allValue := newTestList(var1, var2).ToObject()
+
+	allDefinedDict := newTestDict(var1, val1, var2, val2, var3, val3, nameAttr, nameValue, allAttr, allValue)
+	fooAllDefinedModule := &Module{Object: Object{typ: testModuleType, dict: allDefinedDict}}
+	allUndefinedDict := newTestDict(var1, val1, var2, val2, var3, val3, nameAttr, nameValue)
+	fooAllUndefinedModule := &Module{Object: Object{typ: testModuleType, dict: allUndefinedDict}}
+
+	cases := []struct {
+		module      *Module
+		wantGlobals *Dict
+	}{
+		{
+			fooAllDefinedModule,
+			newTestDict(var1, val1, var2, val2),
+		},
+		{
+			fooAllUndefinedModule,
+			newTestDict(var1, val1, var3, val3),
+		},
+	}
+	for _, cas := range cases {
+		f.globals = NewDict()
+		raised := LoadMembers(f, cas.module.ToObject())
+		if raised != nil {
+			t.Errorf("LoadMmembers: raised %v", raised)
+		}
+		ne := mustNotRaise(NE(f, f.Globals().ToObject(), cas.wantGlobals.ToObject()))
+		b, raised := IsTrue(f, ne)
+		if raised != nil {
+			panic(raised)
+		}
+		if b {
+			t.Errorf("LoadMembers: Globals() = %v, want %v", f.Globals(), cas.wantGlobals)
+		}
+	}
+}
+
 func TestModuleGetNameAndFilename(t *testing.T) {
 	fun := wrapFuncForTest(func(f *Frame, m *Module) (*Tuple, *BaseException) {
 		name, raised := m.GetName(f)