[modules] Partial scope info support of modules

src/objects.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 #include <memory>
 
@@ skipping 861 matching lines @@
 class ConsString;
 class ElementsAccessor;
 class FixedArrayBase;
 class FunctionLiteral;
 class JSGlobalObject;
 class KeyAccumulator;
 class LayoutDescriptor;
 class LiteralsArray;
 class LookupIterator;
 class FieldType;
+class ModuleInfo;
 class ObjectHashTable;
 class ObjectVisitor;
 class PropertyCell;
 class PropertyDescriptor;
 class SafepointEntry;
 class SharedFunctionInfo;
 class StringStream;
 class TypeFeedbackInfo;
 class TypeFeedbackMetadata;
 class TypeFeedbackVector;
@@ skipping 3414 matching lines @@
   inline bool IsAsmModule();
 
   // Return if this is a nested function within an asm module scope.
   inline bool IsAsmFunction();
 
   inline bool HasSimpleParameters();
 
   // Return the function_name if present.
   String* FunctionName();
 
+  ModuleInfo* ModuleDescriptorInfo();
+
   // Return the name of the given parameter.
   String* ParameterName(int var);
 
   // Return the name of the given local.
   String* LocalName(int var);
 
   // Return the name of the given stack local.
   String* StackLocalName(int var);
 
   // Return the name of the given stack local.
@@ skipping 33 matching lines @@
   // Similar to ContextSlotIndex() but this method searches only among
   // global slots of the serialized scope info. Returns the context slot index
   // for a given slot name if the slot is present; otherwise returns a
   // value < 0. The name must be an internalized string. If the slot is present
   // and mode != NULL, sets *mode to the corresponding mode for that variable.
   static int ContextGlobalSlotIndex(Handle<ScopeInfo> scope_info,
                                     Handle<String> name, VariableMode* mode,
                                     InitializationFlag* init_flag,
                                     MaybeAssignedFlag* maybe_assigned_flag);
 
+  // Lookup metadata of a MODULE-allocated variable.  Return a negative value if
+  // there is no module variable with the given name.
+  static int ModuleIndex(Handle<ScopeInfo> scope_info, Handle<String> name,
+                         VariableMode* mode, InitializationFlag* init_flag,
+                         MaybeAssignedFlag* maybe_assigned_flag);
+
   // Lookup the name of a certain context slot by its index.
   String* ContextSlotName(int slot_index);
 
   // Lookup support for serialized scope info. Returns the
   // parameter index for a given parameter name if the parameter is present;
   // otherwise returns a value < 0. The name must be an internalized string.
   int ParameterIndex(String* name);
 
   // Lookup support for serialized scope info. Returns the function context
   // slot index if the function name is present and context-allocated (named
@@ skipping 19 matching lines @@
 #endif
 
   // The layout of the static part of a ScopeInfo is as follows. Each entry is
   // numeric and occupies one array slot.
   // 1. A set of properties of the scope
   // 2. The number of parameters. This only applies to function scopes. For
   //    non-function scopes this is 0.
   // 3. The number of non-parameter variables allocated on the stack.
   // 4. The number of non-parameter and parameter variables allocated in the
   //    context.
+// XXX
 #define FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(V) \
   V(Flags)                                   \
   V(ParameterCount)                          \
   V(StackLocalCount)                         \
   V(ContextLocalCount)                       \
   V(ContextGlobalCount)
 
 #define FIELD_ACCESSORS(name)       \
   inline void Set##name(int value); \
   inline int name();
@@ skipping 44 matching lines @@
   //            b. The context or stack slot index for the variable.
   int ParameterEntriesIndex();
   int StackLocalFirstSlotIndex();
   int StackLocalEntriesIndex();
   int ContextLocalNameEntriesIndex();
   int ContextGlobalNameEntriesIndex();
   int ContextLocalInfoEntriesIndex();
   int ContextGlobalInfoEntriesIndex();
   int ReceiverEntryIndex();
   int FunctionNameEntryIndex();
+  int ModuleInfoEntryIndex();
 
   int Lookup(Handle<String> name, int start, int end, VariableMode* mode,
              VariableLocation* location, InitializationFlag* init_flag,
              MaybeAssignedFlag* maybe_assigned_flag);
 
   // Used for the function name variable for named function expressions, and for
   // the receiver.
   enum VariableAllocationInfo { NONE, STACK, CONTEXT, UNUSED };
 
   // Properties of scopes.
@@ skipping 6689 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_