[modules] Basic support of exports

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 76 matching lines @@
 //           - MapCache
 //         - OrderedHashTable
 //           - OrderedHashSet
 //           - OrderedHashMap
 //         - Context
 //         - TypeFeedbackMetadata
 //         - TypeFeedbackVector
 //         - TemplateList
 //         - TransitionArray
 //         - ScopeInfo
+//         - ModuleInfoEntry
 //         - ModuleInfo
 //         - ScriptContextTable
 //         - WeakFixedArray
 //       - FixedDoubleArray
 //     - Name
 //       - String
 //         - SeqString
 //           - SeqOneByteString
 //           - SeqTwoByteString
 //         - SlicedString
@@ skipping 767 matching lines @@
 class ElementsAccessor;
 class FixedArrayBase;
 class FunctionLiteral;
 class JSGlobalObject;
 class KeyAccumulator;
 class LayoutDescriptor;
 class LiteralsArray;
 class LookupIterator;
 class FieldType;
 class ModuleDescriptor;
+class ModuleInfoEntry;
 class ModuleInfo;
 class ObjectHashTable;
 class ObjectVisitor;
 class PropertyCell;
 class PropertyDescriptor;
 class SafepointEntry;
 class SharedFunctionInfo;
 class StringStream;
 class TypeFeedbackInfo;
 class TypeFeedbackMetadata;
@@ skipping 62 matching lines @@
   V(FixedFloat32Array)           \
   V(FixedFloat64Array)           \
   V(FixedUint8ClampedArray)      \
   V(ByteArray)                   \
   V(BytecodeArray)               \
   V(FreeSpace)                   \
   V(JSReceiver)                  \
   V(JSObject)                    \
   V(JSContextExtensionObject)    \
   V(JSGeneratorObject)           \
+  V(JSModule)                    \
   V(Map)                         \
   V(DescriptorArray)             \
   V(FrameArray)                  \
   V(TransitionArray)             \
   V(LiteralsArray)               \
   V(TypeFeedbackMetadata)        \
   V(TypeFeedbackVector)          \
   V(DeoptimizationInputData)     \
   V(DeoptimizationOutputData)    \
   V(DependentCode)               \
   V(HandlerTable)                \
   V(FixedArray)                  \
   V(FixedDoubleArray)            \
   V(WeakFixedArray)              \
   V(ArrayList)                   \
   V(Context)                     \
   V(ScriptContextTable)          \
   V(NativeContext)               \
   V(ScopeInfo)                   \
+  V(ModuleInfoEntry)             \
   V(ModuleInfo)                  \
   V(JSBoundFunction)             \
   V(JSFunction)                  \
   V(Code)                        \
   V(AbstractCode)                \
   V(Oddball)                     \
   V(SharedFunctionInfo)          \
   V(JSValue)                     \
   V(JSDate)                      \
   V(JSMessageObject)             \
@@ skipping 3403 matching lines @@
 
   // Serializes empty scope info.
   static ScopeInfo* Empty(Isolate* isolate);
 
 #ifdef DEBUG
   void Print();
 #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
+// 1. A set of properties of the scope.
 // 2. The number of parameters. 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.
 #define FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(V) \
   V(Flags)                                   \
   V(ParameterCount)                          \
   V(StackLocalCount)                         \
   V(ContextLocalCount)
 
@@ skipping 92 matching lines @@
       : public BitField<FunctionKind, HasSimpleParametersField::kNext, 9> {};
 
   // Properties of variables.
   class VariableModeField : public BitField<VariableMode, 0, 3> {};
   class InitFlagField : public BitField<InitializationFlag, 3, 1> {};
   class MaybeAssignedFlagField : public BitField<MaybeAssignedFlag, 4, 1> {};
 
   friend class ScopeIterator;
 };
 
+// XXX Name clash
+class ModuleInfoEntry : public FixedArray {
+ public:
+  DECLARE_CAST(ModuleInfoEntry)
+  static Handle<ModuleInfoEntry> New(Isolate* isolate,
+                                     Handle<Object> export_name,
+                                     Handle<Object> local_name,
+                                     Handle<Object> import_name,
+                                     Handle<Object> module_request);
+  inline Object* export_name() const;
+  inline Object* local_name() const;
+  inline Object* import_name() const;
+  inline Object* module_request() const;
+
+ private:
+  friend class Factory;
+  enum {
+    kExportNameIndex,
+    kLocalNameIndex,
+    kImportNameIndex,
+    kModuleRequestIndex,
+    kLength
+  };
+};
+
+// XXX Should I be using Struct rather than FixedArray?
 // ModuleInfo is to ModuleDescriptor what ScopeInfo is to Scope.
 class ModuleInfo : public FixedArray {
  public:
   DECLARE_CAST(ModuleInfo)
   static Handle<ModuleInfo> New(Isolate* isolate, ModuleDescriptor* descr);
   inline FixedArray* special_exports() const;
   inline FixedArray* regular_exports() const;
 
  private:
   friend class Factory;
@@ skipping 3252 matching lines @@
   static const int kInputOrDebugPosOffset = kReceiverOffset + kPointerSize;
   static const int kResumeModeOffset = kInputOrDebugPosOffset + kPointerSize;
   static const int kContinuationOffset = kResumeModeOffset + kPointerSize;
   static const int kOperandStackOffset = kContinuationOffset + kPointerSize;
   static const int kSize = kOperandStackOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
 };
 
+class JSModule : public JSObject {
+ public:
+  DECLARE_CAST(JSModule)
+  DECLARE_VERIFIER(JSModule)
+
+  static const int kSize = JSObject::kHeaderSize;
+
+  static void CreateExport(Handle<JSModule> module,
+                           Handle<String> name);
+  static void StoreExport(Handle<JSModule> module,
+                          Handle<String> name, Handle<Object> value);
+  static Handle<Object> LoadExport(Handle<JSModule> module,
+                                   Handle<String> name);
+};
 
 // JSBoundFunction describes a bound function exotic object.
 class JSBoundFunction : public JSObject {
  public:
   // [bound_target_function]: The wrapped function object.
   DECL_ACCESSORS(bound_target_function, JSReceiver)
 
   // [bound_this]: The value that is always passed as the this value when
   // calling the wrapped function.
   DECL_ACCESSORS(bound_this, Object)
@@ skipping 3398 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_