Usando `super` dentro de uma função de seta dentro de uma função de seta dentro de um método

Question

Oct 05, 2015, 09:58 AM

ecmascript-2015 javascript

Usando `super` dentro de uma função de seta dentro de uma função de seta dentro de um método

Estou tentando descobrir se algum comportamento que estou vendo no Nó v4.1.1 (V8 v4.5.103.33) em relação asuper e as funções de seta sãocomportamento especificado, e se sim (ou de fato, se não),onde está noespecificação que diz que deveria (ou não) funcionar nos vários casos que tenho.

Em resumo: Usandosuper em uma função de seta (inner) dentro de outra função de seta (outer) dentro de um método funcionaa menos que outer possui argumentos ou variáveisinner referências, mesmo queinner referencia argumentos ou variáveis demethod. eu quero sabero que a especificação diz sobre isso: deve funcionar o tempo todo, mesmo onde a V8 está falhando? Em nenhum momento? Somente nos casos específicos em que o V8 está atualmente permitindo que ele funcione, e não onde não está?

Aqui está um MCVE:

"use strict";

class Parent {
    show(msg) {
        console.log(`Parent#show: ${msg}`);
    }
}

class Child extends Parent {
    method(arg) {
        let outer = (x) => {
            console.log(`outer: x = ${x}`);
            let inner = () => {
                super.show(`arg = ${arg}, x = ${x}`);
            };
            inner();
        };
        outer(42);
    }
}

new Child().method("arg");

Isso falha com:

$ node test.js
/path/test.js:13
                super.show(`arg = ${arg}, x = ${x}`);
                ^^^^^

SyntaxError: 'super' keyword unexpected here
    at outer (/path/test.js:16:13)
    at Child.method (/path/test.js:18:9)
    at Object. (/path/test.js:22:13)
    at Module._compile (module.js:434:26)
    at Object.Module._extensions..js (module.js:452:10)
    at Module.load (module.js:355:32)
    at Function.Module._load (module.js:310:12)
    at Function.Module.runMain (module.js:475:10)
    at startup (node.js:117:18)
    at node.js:951:3

Se você remover a referência ax isso está eminner:

            let inner = () => {
                super.show(`arg = ${arg}`); // <== removed x from this
            };

istotrabalho e saídas:

outer: x = 42
Parent#show: arg = arg

Para provar a mim mesmo que o caso "funciona" não era que as funções estavam sendo otimizadas, eu as retirei do método e as chamei. Aqui está um caso um pouco mais complexo (observe os comentários); Esta versãotrabalho:

"use strict";

class Parent2 {
    show(msg) {
        console.log(`Parent2#show: ${msg}`);
    }
}

class Child2 extends Parent2 {
    method(arg) {
        let flag = Math.random() < 0.5;
        console.log(`method called with ${arg}, flag is ${flag}`);
        let x = "A";                 // **A**
        let outer2 = (/*x*/) => {    // **B**
            //let x = "C";           // **C**
            let inner2 = () => {
                super.show(`${x}: ${arg} (${flag})`);
            };
            return inner2;
        };
        return outer2;
    }
}

let o = new Child2().method("arg");
console.log(`type of outer2: ${typeof o}`);
let i = o();
console.log(`type of inner2: ${typeof i}`);
i("B");

Resultado:

method called with arg, flag is false
type of outer2: function
type of inner2: function
Parent2#show: A: arg (false)

Mas se comentarmos a linha rotuladaA e descomente tambémB ouC, ele falha como o MCVE.

Mais notas:

Devo enfatizar que você precisa ter as funções de setaaninhado. outer não tem problemas para acessarsuper. Não quero desordenar a questão com outro grande bloco de código, mas se você adicionarsuper.show(`outer: arg = ${arg}, x = ${x}`); no topo deouter, funciona muito bem.

Como você pode ver,inner usa um argumento e uma variável demethod (bem, o MCVE usa apenas um argumento), e isso é bom, mas assim queinner tenta usar um argumento ou variável deouter, as coisas explodem.

Babel e Traceur estão perfeitamente felizes em transpilar o caso de que o V8 não será executado (aqui eaqui), mas pode ser que eles entendam algo errado que o V8 acerte (ou, é claro, vice-versa).

Não está relacionado a seqüências de caracteres de modelo; a versão anterior ao MCVE não as usava (e usava promessas, e foi assim que terminamos com flechas dentro de flechas).

Apenas para enfatizar, a questão équal é o comportamento especificado aqui eonde na especificação é especificado.

Meu intestino me diz que isso é apenas um bug do V8 - é cedo para esse tipo de coisa, afinal de contas. Mas de qualquer maneira, eu só estou tentando descobrir qual é o comportamentodeveria estar, o que a especificação diz. Eu tentei seguir suas várias e diversas seções falando sobresuper e "objetos básicos" e tal, e francamente eu não estou entendendo.