Problem with using functions when Strict option is enabled, since 3.0.26

[aviv86]

Hi
The following test passes in version 3.0.25 (and older), but started failing since 3.0.26

using Jint;
using Jint.Native;
using Xunit;

namespace Tryouts
{
    public class Program
    {
        public static void Main()
        {
            var script = @"
function execute(doc, args){
    var i = doc;
    {
        function doSomething() {
            return 'ayende';
        }

        i.Name = doSomething();
    }
}
";

            var engine = new Engine(options =>
            {
                options.Strict();
            });
            engine.Execute(script);

            var user = new User();
            var args = new []
            {
                JsValue.FromObject(engine, user)
            };

            var call = engine.GetValue("execute").TryCast<ICallable>();
            call.Call(Undefined.Instance, args); // throws JavaScriptException: 'doSomething is not defined', since version 3.0.26


            Assert.Equal("ayende", user.Name);

        }

        private class User
        {
            public string Name { get; set; }
        }
    }
}

Note that if we remove from the script the curly brackets that start after var i = doc; then the test passes.
Same if Strict option is disabled.

[lahma]

I think the curly brackets make the function block scoped function (at least in strict mode) and it will not be hoisted to outside scope, it's ES6 behavior.

It seems that the function should be visible though for the block when it's only called inside of it.

[aviv86]

Chrome console :

[lahma]

I think the problem is here:

jint/Jint/Runtime/Interpreter/JintStatementList.cs

Lines 114 to 144 in 546f1e8

	internal static void BlockDeclarationInstantiation(
	LexicalEnvironment env,
	List<VariableDeclaration> lexicalDeclarations)
	{
	var envRec = env._record;
	var boundNames = new List<string>();
	for (var i = 0; i < lexicalDeclarations.Count; i++)
	{
	var variableDeclaration = lexicalDeclarations[i];
	boundNames.Clear();
	variableDeclaration.GetBoundNames(boundNames);
	for (var j = 0; j < boundNames.Count; j++)
	{
	var dn = boundNames[j];
	if (variableDeclaration.Kind == VariableDeclarationKind.Const)
	{
	envRec.CreateImmutableBinding(dn, strict: true);
	}
	else
	{
	envRec.CreateMutableBinding(dn, canBeDeleted: false);
	}
	}
	/* If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
	* Let fn be the sole element of the BoundNames of d.
	* Let fo be the result of performing InstantiateFunctionObject for d with argument env.
	* Perform envRec.InitializeBinding(fn, fo).
	*/
	}
	}

If you'd like to implement the missing bits, a PR would be most welcome.

[Jither]

Note that you can't necessarily compare with browser implementation in this - the ECMAScript spec defines different behavior for block level function declarations in browsers vs other ECMAScript implementations. ES6 strict mode in a browser will create both a block scoped and function scoped binding for the function. Outside a browser, things are simpler - the function will be block scoped (and thus not callable from outside the block) in both strict and non-strict mode. https://262.ecma-international.org/6.0/#sec-block-level-function-declarations-web-legacy-compatibility-semantics

(ETA: that's just a clarification - the code in the example should til work as in the browser).

[ppekrol]

I think the problem is here:

jint/Jint/Runtime/Interpreter/JintStatementList.cs

Lines 114 to 144 in 546f1e8

	internal static void BlockDeclarationInstantiation(
	LexicalEnvironment env,
	List<VariableDeclaration> lexicalDeclarations)
	{
	var envRec = env._record;
	var boundNames = new List<string>();
	for (var i = 0; i < lexicalDeclarations.Count; i++)
	{
	var variableDeclaration = lexicalDeclarations[i];
	boundNames.Clear();
	variableDeclaration.GetBoundNames(boundNames);
	for (var j = 0; j < boundNames.Count; j++)
	{
	var dn = boundNames[j];
	if (variableDeclaration.Kind == VariableDeclarationKind.Const)
	{
	envRec.CreateImmutableBinding(dn, strict: true);
	}
	else
	{
	envRec.CreateMutableBinding(dn, canBeDeleted: false);
	}
	}
	/* If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
	* Let fn be the sole element of the BoundNames of d.
	* Let fo be the result of performing InstantiateFunctionObject for d with argument env.
	* Perform envRec.InitializeBinding(fn, fo).
	*/
	}
	}

If you'd like to implement the missing bits, a PR would be most welcome.

@lahma we are not that familiar with all internals and caveats of JS. I would say that it would be saver if one of the Jint contributors could take a look.