3 files changed, 40 insertions, 12 deletions

diff --git a/js/src/frontend/Parser.cpp b/js/src/frontend/Parser.cpp
index cd586ad2a7..997b7ce8ee 100644
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -811,11 +811,18 @@ bool GeneralParser<ParseHandler, Unit>::noteDeclaredPrivateName(
   AddDeclaredNamePtr p = scope->lookupDeclaredNameForAdd(name);
 
   DeclarationKind declKind = DeclarationKind::PrivateName;
-  ClosedOver closedOver = ClosedOver::No;
+
+  // Our strategy for enabling debugger functionality is to mark names as closed
+  // over, even if they don't necessarily need to be, to ensure that they are
+  // included in the environment object. This allows us to easily look them up
+  // by name when needed, even if there is no corresponding property on an
+  // object, as is the case with getter, setters and private methods.
+  ClosedOver closedOver = ClosedOver::Yes;
   PrivateNameKind kind;
   switch (propType) {
     case PropertyType::Field:
       kind = PrivateNameKind::Field;
+      closedOver = ClosedOver::No;
       break;
     case PropertyType::FieldWithAccessor:
       // In this case, we create a new private field for the underlying storage,
@@ -831,11 +838,6 @@ bool GeneralParser<ParseHandler, Unit>::noteDeclaredPrivateName(
         // DeclarationKind::Synthetic.
         declKind = DeclarationKind::PrivateMethod;
       }
-
-      // Methods must be marked closed-over so that
-      // EmitterScope::lookupPrivate() works even if the method is used, but not
-      // within any method (from a computed property name, or debugger frame)
-      closedOver = ClosedOver::Yes;
       kind = PrivateNameKind::Method;
       break;
     case PropertyType::Getter:
@@ -845,7 +847,7 @@ bool GeneralParser<ParseHandler, Unit>::noteDeclaredPrivateName(
       kind = PrivateNameKind::Setter;
       break;
     default:
-      kind = PrivateNameKind::None;
+      MOZ_CRASH("Invalid Property Type for noteDeclarePrivateName");
   }
 
   if (p) {
@@ -8004,7 +8006,11 @@ GeneralParser<ParseHandler, Unit>::classDefinition(
   // position in order to provide it for the nodes created later.
   TokenPos namePos = pos();
 
-  bool isInClass = pc_->sc()->inClass();
+  auto isClass = [](ParseContext::Statement* stmt) {
+    return stmt->kind() == StatementKind::Class;
+  };
+
+  bool isInClass = pc_->sc()->inClass() || pc_->findInnermostStatement(isClass);
 
   // Push a ParseContext::ClassStatement to keep track of the constructor
   // funbox.
diff --git a/js/src/frontend/Stencil.cpp b/js/src/frontend/Stencil.cpp
index 30d1588415..67ed2a90ca 100644
--- a/js/src/frontend/Stencil.cpp
+++ b/js/src/frontend/Stencil.cpp
@@ -759,6 +759,29 @@ void ScopeContext::cacheEnclosingScope(const InputScope& enclosingScope) {
   MOZ_CRASH("Malformed scope chain");
 }
 
+// Given an input scope, possibly refine this to a more precise scope.
+// This is used during eval in the debugger to provide the appropriate scope and
+// ThisBinding kind and environment, which is key to making private field eval
+// work correctly.
+//
+// The trick here is that an eval may have a non-syntatic scope but nevertheless
+// have an 'interesting' environment which can be traversed to find the
+// appropriate scope the the eval to function as desired. See the diagram below.
+//
+// Eval Scope    Eval Env         Frame Env    Frame Scope
+// ============  =============    =========    =============
+//
+// NonSyntactic
+//    |
+//    v
+//   null        DebugEnvProxy                 LexicalScope
+//                     |                            |
+//                     v                            v
+//               DebugEnvProxy --> CallObj --> FunctionScope
+//                     |              |             |
+//                     v              v             v
+//                    ...            ...           ...
+//
 InputScope ScopeContext::determineEffectiveScope(InputScope& scope,
                                                  JSObject* environment) {
   MOZ_ASSERT(effectiveScopeHops == 0);
@@ -4286,8 +4309,8 @@ void js::DumpFunctionFlagsItems(js::JSONPrinter& json,
         case FunctionFlags::Flags::LAMBDA:
           json.value("LAMBDA");
           break;
-        case FunctionFlags::Flags::WASM_JIT_ENTRY:
-          json.value("WASM_JIT_ENTRY");
+        case FunctionFlags::Flags::NATIVE_JIT_ENTRY:
+          json.value("NATIVE_JIT_ENTRY");
           break;
         case FunctionFlags::Flags::HAS_INFERRED_NAME:
           json.value("HAS_INFERRED_NAME");
diff --git a/js/src/frontend/TokenStream.cpp b/js/src/frontend/TokenStream.cpp
index 2134972bf4..7060a6edb1 100644
--- a/js/src/frontend/TokenStream.cpp
+++ b/js/src/frontend/TokenStream.cpp
@@ -1487,9 +1487,8 @@ bool TokenStreamAnyChars::fillExceptingContext(ErrorMetadata* err,
         err->filename = JS::ConstUTF8CharsZ(iter.filename());
         JS::TaggedColumnNumberOneOrigin columnNumber;
         err->lineNumber = iter.computeLine(&columnNumber);
-        // NOTE: Wasm frame cannot appear here.
         err->columnNumber =
-            JS::ColumnNumberOneOrigin(columnNumber.toLimitedColumnNumber());
+            JS::ColumnNumberOneOrigin(columnNumber.oneOriginValue());
         return false;
       }
     }