let, var and const

function outer_func()
{
    {{
        var var01 = "var01";
        let innerLet = "innerLet";//        const innerCst = "innerCst";

        function inner_func()
        {
            alert("inner_func");
        }
    }}
    // var01 is accessible here
    // it's an early error to access innerLet here

    inner_func();
}

outer_func();

GetSuperConstructor

return GetThisEnvironment().[[FunctionObject]].[[GetPrototypeOf]]()

example

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/super : super([arguments]) // calls the parent constructor.

12.3.7.1 Runtime Semantics: Evaluation of super . IdentifierName

SuperProperty : super . IdentifierName:

1. Let env be GetThisEnvironment()// loop up LexicalEnvironment until found an Environment who's HasThisBinding() returns true.
2. Let actualThis be ?env.GetThisBinding()
3. Let propertyKey be StringValue of IdentifierName
4. If the code matched by this SuperProperty is strict mode code, let strict be true; else let strict be false.
5. Let baseValue be ?env.GetSuperBase():
   • Let home be envRec.[[HomeObject]].
   • If home has the value undefined, return undefined.
   • Return ? home.[[GetPrototypeOf]]().
6. Return a value of type Reference that is a Super Reference whose base value component is baseValue, whose referenced name component is propertyKey, whose thisValue component is actualThis, and whose strict reference flag is strict.

Automatic Semicolon Insertion

There are following basic rules of semicolon insertion:

1. When a token is encountered is not allowed by any production of the grammar, then a semicolon is automatically inserted before if one or more of the following conditions is true:
   • The offending token is separated from the previous token by at least one LineTerminator.
   • The offending token is }.
   • The previous token is ) and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement
2. When a token is allowed by some production of the grammar, but the production is a restricted production and
   • the token would be the first token for a terminal or nonterminal immediately following the annotation "[no LineTerminator here]" within the restricted production(and therefore such a token is called a restricted token)
   • the restricted token is separated from the previous token by at least one LineTerminator

However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a for-statement

example 01

The source

return
a + b

is transformed by automatic semicolon insertion into the following:

return;
a + b;

according to rule 2 and `return [no LineTerminator here] Expression`

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)