Bug 1219288 - Add GETIMPORT instruction for accessing module imports that are not namespace imports r=shu

js/src/frontend/BytecodeEmitter.cpp

@@ -1581,6 +1581,25 @@ BytecodeEmitter::tryConvertFreeName(ParseNode* pn)
                         break;
                     }
                 }
+            } else if (ssi.type() == StaticScopeIter<NoGC>::Module) {
+                RootedScript moduleScript(cx, ssi.moduleScript());
+                uint32_t slot_;
+                if (lookupAliasedName(moduleScript, name, &slot_, pn)) {
+                    slot = Some(slot_);
+                    break;
+                }
+
+                // Convert module import accesses to use JSOP_GETIMPORT.
+                RootedModuleEnvironmentObject env(cx, ssi.module().environment());
+                RootedPropertyName propName(cx, name);
+                MOZ_ASSERT(env);
+                if (env->hasImportBinding(propName)) {
+                    if (pn->getOp() == JSOP_GETNAME) {
+                        pn->setOp(JSOP_GETIMPORT);
+                        return true;
+                    }
+                    return false;
+                }
             } else if (ssi.type() == StaticScopeIter<NoGC>::Block) {
                 RootedShape shape(cx, ssi.block().lookupAliasedName(name));
                 if (shape) {
@@ -1856,7 +1875,11 @@ BytecodeEmitter::bindNameToSlotHelper(ParseNode* pn)
       }
 
       case Definition::PLACEHOLDER:
+        return true;
+
       case Definition::IMPORT:
+        if (op == JSOP_GETNAME)
+            pn->setOp(JSOP_GETIMPORT);
         return true;
 
       case Definition::MISSING:

js/src/jit-test/tests/modules/import-in-lazy-function.js

@@ -0,0 +1,11 @@
+// |jit-test| module
+
+// Test that accessing imports in lazily parsed functions works.
+
+import { a } from "module1.js";
+
+function add1(x) {
+    return x + a;
+}
+
+assertEq(add1(2), 3);

js/src/vm/Interpreter.cpp

@@ -204,9 +204,23 @@ GetNameOperation(JSContext* cx, InterpreterFrame* fp, jsbytecode* pc, MutableHan
     JSOp op2 = JSOp(pc[JSOP_GETNAME_LENGTH]);
     if (op2 == JSOP_TYPEOF)
         return FetchName<true>(cx, scopeRoot, pobjRoot, nameRoot, shapeRoot, vp);
+
     return FetchName<false>(cx, scopeRoot, pobjRoot, nameRoot, shapeRoot, vp);
 }
 
+static inline bool
+GetImportOperation(JSContext* cx, InterpreterFrame* fp, jsbytecode* pc, MutableHandleValue vp)
+{
+    RootedObject obj(cx, fp->scopeChain()), scope(cx), pobj(cx);
+    RootedPropertyName name(cx, fp->script()->getName(pc));
+    RootedShape shape(cx);
+
+    MOZ_ALWAYS_TRUE(LookupName(cx, name, obj, &scope, &pobj, &shape));
+    MOZ_ASSERT(scope && scope->is<ModuleEnvironmentObject>());
+    MOZ_ASSERT(scope->as<ModuleEnvironmentObject>().hasImportBinding(name));
+    return FetchName<false>(cx, scope, pobj, name, shape, vp);
+}
+
 static bool
 SetPropertyOperation(JSContext* cx, JSOp op, HandleValue lval, HandleId id, HandleValue rval)
 {
@@ -1694,7 +1708,6 @@ CASE(JSOP_NOP)
 CASE(JSOP_UNUSED14)
 CASE(JSOP_BACKPATCH)
 CASE(JSOP_UNUSED145)
-CASE(JSOP_UNUSED176)
 CASE(JSOP_UNUSED177)
 CASE(JSOP_UNUSED178)
 CASE(JSOP_UNUSED179)
@@ -2819,6 +2832,17 @@ CASE(JSOP_GETNAME)
 }
 END_CASE(JSOP_GETNAME)
 
+CASE(JSOP_GETIMPORT)
+{
+    PUSH_NULL();
+    MutableHandleValue rval = REGS.stackHandleAt(-1);
+    if (!GetImportOperation(cx, REGS.fp(), REGS.pc, rval))
+        goto error;
+
+    TypeScript::Monitor(cx, script, REGS.pc, rval);
+}
+END_CASE(JSOP_GETIMPORT)
+
 CASE(JSOP_GETINTRINSIC)
 {
     ReservedRooted<Value> rval(&rootValue0);

js/src/vm/Opcodes.h

@@ -1801,7 +1801,14 @@
      *   Stack: obj, id, val => obj
      */ \
     macro(JSOP_INITHIDDENELEM,  175, "inithiddenelem",   NULL,         1,  3,  1, JOF_BYTE|JOF_ELEM|JOF_SET|JOF_DETECTING) \
-    macro(JSOP_UNUSED176,     176,"unused176",  NULL,     1,  0,  0,  JOF_BYTE) \
+    /*
+     * Gets the value of a module import by name and pushes it onto the stack.
+     *   Category: Variables and Scopes
+     *   Type: Variables
+     *   Operands: uint32_t nameIndex
+     *   Stack: => val
+     */ \
+    macro(JSOP_GETIMPORT,     176,"getimport",  NULL,     5,  0,  1,  JOF_ATOM|JOF_NAME|JOF_TYPESET) \
     macro(JSOP_UNUSED177,     177,"unused177",  NULL,     1,  0,  0,  JOF_BYTE) \
     macro(JSOP_UNUSED178,     178,"unused178",  NULL,     1,  0,  0,  JOF_BYTE) \
     macro(JSOP_UNUSED179,     179,"unused179",  NULL,     1,  0,  0,  JOF_BYTE) \

js/src/vm/ScopeObject.cpp

@@ -423,6 +423,12 @@ ModuleEnvironmentObject::createImportBinding(JSContext* cx, HandleAtom importNam
     return true;
 }
 
+bool
+ModuleEnvironmentObject::hasImportBinding(HandlePropertyName name)
+{
+    return importBindings().has(NameToId(name));
+}
+
 /* static */ bool
 ModuleEnvironmentObject::lookupProperty(JSContext* cx, HandleObject obj, HandleId id,
                                         MutableHandleObject objp, MutableHandleShape propp)

js/src/vm/ScopeObject.h

@@ -401,6 +401,8 @@ class ModuleEnvironmentObject : public LexicalScopeBase
     bool createImportBinding(JSContext* cx, HandleAtom importName, HandleModuleObject module,
                              HandleAtom exportName);
 
+    bool hasImportBinding(HandlePropertyName name);
+
   private:
     static bool lookupProperty(JSContext* cx, HandleObject obj, HandleId id,
                                MutableHandleObject objp, MutableHandleShape propp);