ReservedWord

IdentifierName can be devided into ReservedWord and Identifier.

A keyword is a token that matches IdentifierName, but also has a syntactic use.

Many keywords are reserved words, but some are reserved only in certain contexts. contextual keywords(await and yield) belong to ReservedWord but sometimes can be used as identifiers.

Followings belong to Identifier but not intepreted as so under certain syntactic productions:

• let, static
• implements, interface, package, private, protected, public; but in future, they will become reserved.
• as, async, from, get, meta, of, set

Proxy Objects

A proxy object is an exotic object whose essential internal methods are partially implemented using ECMAScript code. Every proxy object has an internal slot called [[ProxyHandler]]. The value of [[ProxyHandler]] is an object, called the proxy's handler object, or null. Every proxy object also has an internal slot called [[ProxyTarget]] whose value is either an object or the null value. This object is called the proxy's target object.

When a handler method is called to provide the implementation of a proxy object internal method, the handler method is passed the proxy's target object as a parameter. Invoking an internal method on the proxy results in the invocation of the corresponding internal method on the proxy's target object if the handler object does not have a method corresponding to the internal trap.

[[GetPrototypeOf]] ( )

1. Let trap be ? GetMethod(handler, "getPrototypeOf").
2. If not IsExtensible(target) or trap is undefined, Return ? target.[[GetPrototypeOf]]().
3. return call trap on target to get target's prototype

[[SetPrototypeOf]] ( V )

1. if not IsExtensible(target), return true
2. Let trap be ? GetMethod(handler, "setPrototypeOf").
3. If trap is undefined, Return ? target.[[SetPrototypeOf]](V).
4. return call trap on target&V to set target's prototype

Arguments Exotic Objects

Most ECMAScript functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an ordinary object or an arguments exotic object.

An arguments exotic object is an exotic object whose array index properties map to the formal parameters bindings.

Arguments exotic objects have a [[ParameterMap]] internal slot. Ordinary arguments objects also have a [[ParameterMap]] internal slot whose value is always undefined.

[[GetOwnProperty]] ( P )

1. Let args be the arguments object.
2. Let desc be OrdinaryGetOwnProperty(args, P).
3. If desc is undefined, return desc.
4. Let map be args.[[ParameterMap]].
5. Let isMapped be HasOwnProperty(map, P).
6. If isMapped, set desc.[[Value]] to Get(map, P)
7. Return desc.

[[DefineOwnProperty]] ( P, Desc )

1. Let newArgDesc be Desc.
2. If isMapped and Desc.[[Value]] is not present and Desc.[[Writable]] is false,

       Set newArgDesc to a copy of Desc except newArgDesc.[[Value]] as Get(map, P)
       

3. if not OrdinaryDefineOwnProperty(args, P, newArgDesc), return false.
4. If isMapped is false, return true
5. If IsAccessorDescriptor(Desc), call map.[[Delete]](P) and return true
6. If Desc.[[Value]] is present, Set(map, P, Desc.[[Value]], false).
7. If Desc.[[Writable]] is false, Call map.[[Delete]](P)

PrepareForOrdinaryCall

PrepareForOrdinaryCall( F, newTarget ) where F is a function object and newTarget is Undefined or Object:

1. let calleeContext be a new code execution context as:
   • .LexicalEnvironment = .VariableEnvironment = NewFunctionEnvironment(F, newTarget)
   • .Function = F
   • .ScriptOrModule = F.[[ScriptOrModule]]
   • .Realm = F.[[Realm]]
2. Push calleeContext onto the execution context stack; suspending the old while making calleeContext the running context
3. return calleeContext

SameValue, SameValueZero and Strict Equality Comparison

SameValue differs from the Strict Equality Comparison Algorithm in its treatment of signed zeroes and NaNs: +0 === -0 and !(NaN === NaN)

SameValueZero differs from SameValue only in its treatment of +0 and -0.

NewGlobalEnvironment

NewGlobalEnvironment ( G, thisValue ) returns a new global env who's outer lexical environment is null and its global Environment Record created as globalRec:

1. .[[ObjectRecord]]: a new object Environment Record who's binding object is G
2. .[[DeclarativeRecord]]: a new declarative Environment Record; [[VarNames]]: a new empty List.
3. .[[GlobalThisValue]]: thisValue (zxxu: thisValue and G means different stuff? according to SetRealmGlobalObject and InitializeHostDefinedRealm, they can be the same but also can be different)

NewFunctionEnvironment

NewFunctionEnvironment ( F, newTarget ):

1. Assert: Type(newTarget) is Undefined or Object.
2. Let envRec be a new function Environment Record containing no bindings.
3. Set envRec.[[FunctionObject]] to F.
4. If F.[[ThisMode]] is lexical, set envRec.[[ThisBindingStatus]] to lexical.
5. Else, set envRec.[[ThisBindingStatus]] to uninitialized.
6. Set envRec.[[HomeObject]] to F.[[HomeObject]].
7. Set envRec.[[NewTarget]] to newTarget.
8. Return a new Lexical Environment who's EnvironmentRecord is envRec and outer lexical environment is F.[[Environment]].