--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -979,18 +979,18 @@ LookupStdName(const JSAtomState& names, 
     return nullptr;
 }
 
 /*
  * Table of standard classes, indexed by JSProtoKey. For entries where the
  * JSProtoKey does not correspond to a class with a meaningful constructor, we
  * insert a null entry into the table.
  */
-#define STD_NAME_ENTRY(name, code, init, clasp) { EAGER_ATOM(name), static_cast<JSProtoKey>(code) },
-#define STD_DUMMY_ENTRY(name, code, init, dummy) { 0, JSProto_Null },
+#define STD_NAME_ENTRY(name, init, clasp) { EAGER_ATOM(name), JSProto_##name },
+#define STD_DUMMY_ENTRY(name, init, dummy) { 0, JSProto_Null },
 static const JSStdName standard_class_names[] = {
   JS_FOR_PROTOTYPES(STD_NAME_ENTRY, STD_DUMMY_ENTRY)
   { 0, JSProto_LIMIT }
 };
 
 /*
  * Table of top-level function and constant names and the JSProtoKey of the
  * standard class that initializes them.

--- a/js/src/jsatom.cpp
+++ b/js/src/jsatom.cpp
@@ -44,17 +44,17 @@ const char*
 js::AtomToPrintableString(JSContext* cx, JSAtom* atom, JSAutoByteString* bytes)
 {
     JSString* str = QuoteString(cx, atom, 0);
     if (!str)
         return nullptr;
     return bytes->encodeLatin1(cx, str);
 }
 
-#define DEFINE_PROTO_STRING(name,code,init,clasp) const char js_##name##_str[] = #name;
+#define DEFINE_PROTO_STRING(name,init,clasp) const char js_##name##_str[] = #name;
 JS_FOR_EACH_PROTOTYPE(DEFINE_PROTO_STRING)
 #undef DEFINE_PROTO_STRING
 
 #define CONST_CHAR_STR(idpart, id, text) const char js_##idpart##_str[] = text;
 FOR_EACH_COMMON_PROPERTYNAME(CONST_CHAR_STR)
 #undef CONST_CHAR_STR
 
 /* Constant strings that are not atomized. */
@@ -100,17 +100,17 @@ JSRuntime::initializeAtoms(JSContext* cx
     staticStrings = cx->new_<StaticStrings>();
     if (!staticStrings || !staticStrings->init(cx))
         return false;
 
     static const CommonNameInfo cachedNames[] = {
 #define COMMON_NAME_INFO(idpart, id, text) { js_##idpart##_str, sizeof(text) - 1 },
         FOR_EACH_COMMON_PROPERTYNAME(COMMON_NAME_INFO)
 #undef COMMON_NAME_INFO
-#define COMMON_NAME_INFO(name, code, init, clasp) { js_##name##_str, sizeof(#name) - 1 },
+#define COMMON_NAME_INFO(name, init, clasp) { js_##name##_str, sizeof(#name) - 1 },
         JS_FOR_EACH_PROTOTYPE(COMMON_NAME_INFO)
 #undef COMMON_NAME_INFO
 #define COMMON_NAME_INFO(name) { #name, sizeof(#name) - 1 },
         JS_FOR_EACH_WELL_KNOWN_SYMBOL(COMMON_NAME_INFO)
 #undef COMMON_NAME_INFO
 #define COMMON_NAME_INFO(name) { "Symbol." #name, sizeof("Symbol." #name) - 1 },
         JS_FOR_EACH_WELL_KNOWN_SYMBOL(COMMON_NAME_INFO)
 #undef COMMON_NAME_INFO

--- a/js/src/jsatom.h
+++ b/js/src/jsatom.h
@@ -137,17 +137,17 @@ AtomIsPinned(JSContext* cx, JSAtom* atom
 
 // This may be called either with or without the atoms lock held.
 extern bool
 AtomIsPinnedInRuntime(JSRuntime* rt, JSAtom* atom);
 
 #endif // DEBUG
 
 /* Well-known predefined C strings. */
-#define DECLARE_PROTO_STR(name,code,init,clasp) extern const char js_##name##_str[];
+#define DECLARE_PROTO_STR(name,init,clasp) extern const char js_##name##_str[];
 JS_FOR_EACH_PROTOTYPE(DECLARE_PROTO_STR)
 #undef DECLARE_PROTO_STR
 
 #define DECLARE_CONST_CHAR_STR(idpart, id, text)  extern const char js_##idpart##_str[];
 FOR_EACH_COMMON_PROPERTYNAME(DECLARE_CONST_CHAR_STR)
 #undef DECLARE_CONST_CHAR_STR
 
 /* Constant strings that are not atomized. */

--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -3311,18 +3311,18 @@ GetObjectSlotNameFunctor::operator()(JS:
     if (!shape) {
         do {
             const char* slotname = nullptr;
             const char* pattern = nullptr;
             if (obj->is<GlobalObject>()) {
                 pattern = "CLASS_OBJECT(%s)";
                 if (false)
                     ;
-#define TEST_SLOT_MATCHES_PROTOTYPE(name,code,init,clasp) \
-                else if ((code) == slot) { slotname = js_##name##_str; }
+#define TEST_SLOT_MATCHES_PROTOTYPE(name,init,clasp) \
+                else if ((JSProto_##name) == slot) { slotname = js_##name##_str; }
                 JS_FOR_EACH_PROTOTYPE(TEST_SLOT_MATCHES_PROTOTYPE)
 #undef TEST_SLOT_MATCHES_PROTOTYPE
             } else {
                 pattern = "%s";
                 if (obj->is<EnvironmentObject>()) {
                     if (slot == EnvironmentObject::enclosingEnvironmentSlot()) {
                         slotname = "enclosing_environment";
                     } else if (obj->is<CallObject>()) {

--- a/js/src/jsprototypes.h
+++ b/js/src/jsprototypes.h
@@ -5,19 +5,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jsprototypes_h
 #define jsprototypes_h
 
 /* A higher-order macro for enumerating all JSProtoKey values. */
 /*
  * Consumers define macros as follows:
- * macro(name, code, init, clasp)
+ * macro(name, init, clasp)
  *   name:    The canonical name of the class.
- *   code:    The enumerator code. There are part of the XDR API, and must not change.
  *   init:    Initialization function. These are |extern "C";|, and clients should use
  *            |extern "C" {}| as appropriate when using this macro.
  *   clasp:   The JSClass for this object, or "dummy" if it doesn't exist.
  *
  *
  * Consumers wishing to iterate over all the JSProtoKey values, can use
  * JS_FOR_EACH_PROTOTYPE. However, there are certain values that don't correspond
  * to real constructors, like Null or constructors that are disabled via
@@ -57,79 +56,79 @@
 
 #ifdef ENABLE_SHARED_ARRAY_BUFFER
 #define IF_SAB(real,imaginary) real
 #else
 #define IF_SAB(real,imaginary) imaginary
 #endif
 
 #define JS_FOR_PROTOTYPES(real,imaginary) \
-    imaginary(Null,              0,     InitNullClass,          dummy) \
-    real(Object,                 1,     InitViaClassSpec,       OCLASP(Plain)) \
-    real(Function,               2,     InitViaClassSpec,       &JSFunction::class_) \
-    real(Array,                  3,     InitViaClassSpec,       OCLASP(Array)) \
-    real(Boolean,                4,     InitBooleanClass,       OCLASP(Boolean)) \
-    real(JSON,                   5,     InitJSONClass,          CLASP(JSON)) \
-    real(Date,                   6,     InitViaClassSpec,       OCLASP(Date)) \
-    real(Math,                   7,     InitMathClass,          CLASP(Math)) \
-    real(Number,                 8,     InitNumberClass,        OCLASP(Number)) \
-    real(String,                 9,     InitStringClass,        OCLASP(String)) \
-    real(RegExp,                10,     InitViaClassSpec,       OCLASP(RegExp)) \
-    real(Error,                 11,     InitViaClassSpec,       ERROR_CLASP(JSEXN_ERR)) \
-    real(InternalError,         12,     InitViaClassSpec,       ERROR_CLASP(JSEXN_INTERNALERR)) \
-    real(EvalError,             13,     InitViaClassSpec,       ERROR_CLASP(JSEXN_EVALERR)) \
-    real(RangeError,            14,     InitViaClassSpec,       ERROR_CLASP(JSEXN_RANGEERR)) \
-    real(ReferenceError,        15,     InitViaClassSpec,       ERROR_CLASP(JSEXN_REFERENCEERR)) \
-    real(SyntaxError,           16,     InitViaClassSpec,       ERROR_CLASP(JSEXN_SYNTAXERR)) \
-    real(TypeError,             17,     InitViaClassSpec,       ERROR_CLASP(JSEXN_TYPEERR)) \
-    real(URIError,              18,     InitViaClassSpec,       ERROR_CLASP(JSEXN_URIERR)) \
-    real(DebuggeeWouldRun,      19,     InitViaClassSpec,       ERROR_CLASP(JSEXN_DEBUGGEEWOULDRUN)) \
-    real(CompileError,          20,     InitViaClassSpec,       ERROR_CLASP(JSEXN_WASMCOMPILEERROR)) \
-    real(LinkError,             21,     InitViaClassSpec,       ERROR_CLASP(JSEXN_WASMLINKERROR)) \
-    real(RuntimeError,          22,     InitViaClassSpec,       ERROR_CLASP(JSEXN_WASMRUNTIMEERROR)) \
-    real(Iterator,              23,     InitLegacyIteratorClass,OCLASP(PropertyIterator)) \
-    real(StopIteration,         24,     InitStopIterationClass, OCLASP(StopIteration)) \
-    real(ArrayBuffer,           25,     InitViaClassSpec,       OCLASP(ArrayBuffer)) \
-    real(Int8Array,             26,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Int8)) \
-    real(Uint8Array,            27,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint8)) \
-    real(Int16Array,            28,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Int16)) \
-    real(Uint16Array,           29,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint16)) \
-    real(Int32Array,            30,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Int32)) \
-    real(Uint32Array,           31,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint32)) \
-    real(Float32Array,          32,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Float32)) \
-    real(Float64Array,          33,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Float64)) \
-    real(Uint8ClampedArray,     34,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint8Clamped)) \
-    real(Proxy,                 35,     InitProxyClass,         js::ProxyClassPtr) \
-    real(WeakMap,               36,     InitWeakMapClass,       OCLASP(WeakMap)) \
-    real(Map,                   37,     InitViaClassSpec,       OCLASP(Map)) \
-    real(Set,                   38,     InitViaClassSpec,       OCLASP(Set)) \
-    real(DataView,              39,     InitViaClassSpec,       OCLASP(DataView)) \
-    real(Symbol,                40,     InitSymbolClass,        OCLASP(Symbol)) \
-IF_SAB(real,imaginary)(SharedArrayBuffer,       41,     InitViaClassSpec, OCLASP(SharedArrayBuffer)) \
-IF_INTL(real,imaginary) (Intl,                  42,     InitIntlClass,          CLASP(Intl)) \
-IF_BDATA(real,imaginary)(TypedObject,           43,     InitTypedObjectModuleObject,   OCLASP(TypedObjectModule)) \
-    real(Reflect,               44,     InitReflect,            nullptr) \
-IF_SIMD(real,imaginary)(SIMD,                   45,     InitSimdClass, OCLASP(Simd)) \
-    real(WeakSet,               46,     InitWeakSetClass,       OCLASP(WeakSet)) \
-    real(TypedArray,            47,     InitViaClassSpec,       &js::TypedArrayObject::sharedTypedArrayPrototypeClass) \
-IF_SAB(real,imaginary)(Atomics, 48,     InitAtomicsClass, OCLASP(Atomics)) \
-    real(SavedFrame,            49,     InitViaClassSpec,       &js::SavedFrame::class_) \
-    real(Promise,               50,     InitViaClassSpec,       OCLASP(Promise)) \
-    real(ReadableStream,        51,     InitViaClassSpec,       &js::ReadableStream::class_) \
-    real(ReadableStreamDefaultReader,           52,     InitViaClassSpec, &js::ReadableStreamDefaultReader::class_) \
-    real(ReadableStreamBYOBReader,              53,     InitViaClassSpec, &js::ReadableStreamBYOBReader::class_) \
-    real(ReadableStreamDefaultController,       54,     InitViaClassSpec, &js::ReadableStreamDefaultController::class_) \
-    real(ReadableByteStreamController,          55,     InitViaClassSpec, &js::ReadableByteStreamController::class_) \
-    real(ReadableStreamBYOBRequest,             56,     InitViaClassSpec, &js::ReadableStreamBYOBRequest::class_) \
-    imaginary(WritableStream,   57,     dummy,                  dummy) \
-    imaginary(WritableStreamDefaultWriter,      58,     dummy,  dummy) \
-    imaginary(WritableStreamDefaultController,  59,     dummy,  dummy) \
-    real(ByteLengthQueuingStrategy,             60,     InitViaClassSpec, &js::ByteLengthQueuingStrategy::class_) \
-    real(CountQueuingStrategy,  61,      InitViaClassSpec,      &js::CountQueuingStrategy::class_) \
-    real(WebAssembly,           62,     InitWebAssemblyClass,   CLASP(WebAssembly)) \
-    imaginary(WasmModule,       63,     dummy,                  dummy) \
-    imaginary(WasmInstance,     64,     dummy,                  dummy) \
-    imaginary(WasmMemory,       65,     dummy,                  dummy) \
-    imaginary(WasmTable,        66,     dummy,                  dummy) \
+    imaginary(Null,             InitNullClass,          dummy) \
+    real(Object,                InitViaClassSpec,       OCLASP(Plain)) \
+    real(Function,              InitViaClassSpec,       &JSFunction::class_) \
+    real(Array,                 InitViaClassSpec,       OCLASP(Array)) \
+    real(Boolean,               InitBooleanClass,       OCLASP(Boolean)) \
+    real(JSON,                  InitJSONClass,          CLASP(JSON)) \
+    real(Date,                  InitViaClassSpec,       OCLASP(Date)) \
+    real(Math,                  InitMathClass,          CLASP(Math)) \
+    real(Number,                InitNumberClass,        OCLASP(Number)) \
+    real(String,                InitStringClass,        OCLASP(String)) \
+    real(RegExp,                InitViaClassSpec,       OCLASP(RegExp)) \
+    real(Error,                 InitViaClassSpec,       ERROR_CLASP(JSEXN_ERR)) \
+    real(InternalError,         InitViaClassSpec,       ERROR_CLASP(JSEXN_INTERNALERR)) \
+    real(EvalError,             InitViaClassSpec,       ERROR_CLASP(JSEXN_EVALERR)) \
+    real(RangeError,            InitViaClassSpec,       ERROR_CLASP(JSEXN_RANGEERR)) \
+    real(ReferenceError,        InitViaClassSpec,       ERROR_CLASP(JSEXN_REFERENCEERR)) \
+    real(SyntaxError,           InitViaClassSpec,       ERROR_CLASP(JSEXN_SYNTAXERR)) \
+    real(TypeError,             InitViaClassSpec,       ERROR_CLASP(JSEXN_TYPEERR)) \
+    real(URIError,              InitViaClassSpec,       ERROR_CLASP(JSEXN_URIERR)) \
+    real(DebuggeeWouldRun,      InitViaClassSpec,       ERROR_CLASP(JSEXN_DEBUGGEEWOULDRUN)) \
+    real(CompileError,          InitViaClassSpec,       ERROR_CLASP(JSEXN_WASMCOMPILEERROR)) \
+    real(LinkError,             InitViaClassSpec,       ERROR_CLASP(JSEXN_WASMLINKERROR)) \
+    real(RuntimeError,          InitViaClassSpec,       ERROR_CLASP(JSEXN_WASMRUNTIMEERROR)) \
+    real(Iterator,              InitLegacyIteratorClass,OCLASP(PropertyIterator)) \
+    real(StopIteration,         InitStopIterationClass, OCLASP(StopIteration)) \
+    real(ArrayBuffer,           InitViaClassSpec,       OCLASP(ArrayBuffer)) \
+    real(Int8Array,             InitViaClassSpec,       TYPED_ARRAY_CLASP(Int8)) \
+    real(Uint8Array,            InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint8)) \
+    real(Int16Array,            InitViaClassSpec,       TYPED_ARRAY_CLASP(Int16)) \
+    real(Uint16Array,           InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint16)) \
+    real(Int32Array,            InitViaClassSpec,       TYPED_ARRAY_CLASP(Int32)) \
+    real(Uint32Array,           InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint32)) \
+    real(Float32Array,          InitViaClassSpec,       TYPED_ARRAY_CLASP(Float32)) \
+    real(Float64Array,          InitViaClassSpec,       TYPED_ARRAY_CLASP(Float64)) \
+    real(Uint8ClampedArray,     InitViaClassSpec,       TYPED_ARRAY_CLASP(Uint8Clamped)) \
+    real(Proxy,                 InitProxyClass,         js::ProxyClassPtr) \
+    real(WeakMap,               InitWeakMapClass,       OCLASP(WeakMap)) \
+    real(Map,                   InitViaClassSpec,       OCLASP(Map)) \
+    real(Set,                   InitViaClassSpec,       OCLASP(Set)) \
+    real(DataView,              InitViaClassSpec,       OCLASP(DataView)) \
+    real(Symbol,                InitSymbolClass,        OCLASP(Symbol)) \
+IF_SAB(real,imaginary)(SharedArrayBuffer,       InitViaClassSpec, OCLASP(SharedArrayBuffer)) \
+IF_INTL(real,imaginary) (Intl,                  InitIntlClass,          CLASP(Intl)) \
+IF_BDATA(real,imaginary)(TypedObject,           InitTypedObjectModuleObject,   OCLASP(TypedObjectModule)) \
+    real(Reflect,               InitReflect,            nullptr) \
+IF_SIMD(real,imaginary)(SIMD,                   InitSimdClass, OCLASP(Simd)) \
+    real(WeakSet,               InitWeakSetClass,       OCLASP(WeakSet)) \
+    real(TypedArray,            InitViaClassSpec,       &js::TypedArrayObject::sharedTypedArrayPrototypeClass) \
+IF_SAB(real,imaginary)(Atomics, InitAtomicsClass, OCLASP(Atomics)) \
+    real(SavedFrame,            InitViaClassSpec,       &js::SavedFrame::class_) \
+    real(Promise,               InitViaClassSpec,       OCLASP(Promise)) \
+    real(ReadableStream,        InitViaClassSpec,       &js::ReadableStream::class_) \
+    real(ReadableStreamDefaultReader,           InitViaClassSpec, &js::ReadableStreamDefaultReader::class_) \
+    real(ReadableStreamBYOBReader,              InitViaClassSpec, &js::ReadableStreamBYOBReader::class_) \
+    real(ReadableStreamDefaultController,       InitViaClassSpec, &js::ReadableStreamDefaultController::class_) \
+    real(ReadableByteStreamController,          InitViaClassSpec, &js::ReadableByteStreamController::class_) \
+    real(ReadableStreamBYOBRequest,             InitViaClassSpec, &js::ReadableStreamBYOBRequest::class_) \
+    imaginary(WritableStream,   dummy,                  dummy) \
+    imaginary(WritableStreamDefaultWriter,      dummy,  dummy) \
+    imaginary(WritableStreamDefaultController,  dummy,  dummy) \
+    real(ByteLengthQueuingStrategy,             InitViaClassSpec, &js::ByteLengthQueuingStrategy::class_) \
+    real(CountQueuingStrategy,  InitViaClassSpec,       &js::CountQueuingStrategy::class_) \
+    real(WebAssembly,           InitWebAssemblyClass,   CLASP(WebAssembly)) \
+    imaginary(WasmModule,       dummy,                  dummy) \
+    imaginary(WasmInstance,     dummy,                  dummy) \
+    imaginary(WasmMemory,       dummy,                  dummy) \
+    imaginary(WasmTable,        dummy,                  dummy) \
 
 #define JS_FOR_EACH_PROTOTYPE(macro) JS_FOR_PROTOTYPES(macro,macro)
 
 #endif /* jsprototypes_h */

--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -72,17 +72,17 @@ enum JSType {
     JSTYPE_BOOLEAN,             /* boolean */
     JSTYPE_NULL,                /* null */
     JSTYPE_SYMBOL,              /* symbol */
     JSTYPE_LIMIT
 };
 
 /* Dense index into cached prototypes and class atoms for standard objects. */
 enum JSProtoKey {
-#define PROTOKEY_AND_INITIALIZER(name,code,init,clasp) JSProto_##name = code,
+#define PROTOKEY_AND_INITIALIZER(name,init,clasp) JSProto_##name,
     JS_FOR_EACH_PROTOTYPE(PROTOKEY_AND_INITIALIZER)
 #undef PROTOKEY_AND_INITIALIZER
     JSProto_LIMIT
 };
 
 /* Struct forward declarations. */
 struct JSClass;
 struct JSCompartment;

--- a/js/src/vm/GlobalObject.cpp
+++ b/js/src/vm/GlobalObject.cpp
@@ -51,32 +51,32 @@ using namespace js;
 
 struct ProtoTableEntry {
     const Class* clasp;
     ClassInitializerOp init;
 };
 
 namespace js {
 
-#define DECLARE_PROTOTYPE_CLASS_INIT(name,code,init,clasp) \
+#define DECLARE_PROTOTYPE_CLASS_INIT(name,init,clasp) \
     extern JSObject* init(JSContext* cx, Handle<JSObject*> obj);
 JS_FOR_EACH_PROTOTYPE(DECLARE_PROTOTYPE_CLASS_INIT)
 #undef DECLARE_PROTOTYPE_CLASS_INIT
 
 } // namespace js
 
 JSObject*
 js::InitViaClassSpec(JSContext* cx, Handle<JSObject*> obj)
 {
     MOZ_CRASH("InitViaClassSpec() should not be called.");
 }
 
 static const ProtoTableEntry protoTable[JSProto_LIMIT] = {
-#define INIT_FUNC(name,code,init,clasp) { clasp, init },
-#define INIT_FUNC_DUMMY(name,code,init,clasp) { nullptr, nullptr },
+#define INIT_FUNC(name,init,clasp) { clasp, init },
+#define INIT_FUNC_DUMMY(name,init,clasp) { nullptr, nullptr },
     JS_FOR_PROTOTYPES(INIT_FUNC, INIT_FUNC_DUMMY)
 #undef INIT_FUNC_DUMMY
 #undef INIT_FUNC
 };
 
 JS_FRIEND_API(const js::Class*)
 js::ProtoKeyToClass(JSProtoKey key)
 {

--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -195,17 +195,17 @@ struct RuntimeSizes;
 } // namespace JS
 
 /* Various built-in or commonly-used names pinned on first context. */
 struct JSAtomState
 {
 #define PROPERTYNAME_FIELD(idpart, id, text) js::ImmutablePropertyNamePtr id;
     FOR_EACH_COMMON_PROPERTYNAME(PROPERTYNAME_FIELD)
 #undef PROPERTYNAME_FIELD
-#define PROPERTYNAME_FIELD(name, code, init, clasp) js::ImmutablePropertyNamePtr name;
+#define PROPERTYNAME_FIELD(name, init, clasp) js::ImmutablePropertyNamePtr name;
     JS_FOR_EACH_PROTOTYPE(PROPERTYNAME_FIELD)
 #undef PROPERTYNAME_FIELD
 #define PROPERTYNAME_FIELD(name) js::ImmutablePropertyNamePtr name;
     JS_FOR_EACH_WELL_KNOWN_SYMBOL(PROPERTYNAME_FIELD)
 #undef PROPERTYNAME_FIELD
 #define PROPERTYNAME_FIELD(name) js::ImmutablePropertyNamePtr Symbol_##name;
     JS_FOR_EACH_WELL_KNOWN_SYMBOL(PROPERTYNAME_FIELD)
 #undef PROPERTYNAME_FIELD