(Inspirado por este comentário em uma pergunta antiga.)

fundo

Um erro quine (também conhecido como "Kimian quine") é um programa que, quando compilado ou executado, faz com que o compilador / intérprete / tempo de execução imprima uma mensagem de erro com texto idêntico ao próprio programa e nada mais. Para os propósitos deste desafio, estamos definindo "erro" de forma ampla, para incluir também avisos.

Tarefa

Neste desafio, estamos procurando uma solução que também seja uma solução de erro. Quando executado, o programa deve imprimir seu próprio código-fonte normalmente (ou seja, não como uma mensagem de erro / aviso); isso deve ser uma solução adequada (ou seja, alguma parte do programa deve codificar uma parte diferente da saída). Além disso, a compilação e execução do programa também devem fazer com que o código-fonte do programa - e nada mais - seja impresso como mensagens de erro ou aviso pela implementação. (Observe que isso significa que você não poderá usar erros em tempo de compilação, nos idiomas em que esses impedem a execução normal do programa.) Portanto, em outras palavras, o código-fonte do programa será impresso duas vezes, uma vez por cada método.

Esclarecimentos

• Na maioria dos casos, será óbvio o que é e o que não é uma mensagem de erro / aviso; não estamos distinguindo entre os dois aqui. Em casos ambíguos, defina uma mensagem de erro / aviso como qualquer texto produzido pela implementação: 1. como consequência de algo que não seja a execução de um comando (ou o equivalente mais próximo da linguagem); ou 2. que não fazia parte da entrada do comando que a produziu como saída.
• A parte de erro / aviso do quine não precisa ser adequada (embora na maioria dos casos seja por acaso, pois a maioria das mensagens de erro e aviso contém quantidades consideráveis ​​de texto fixo).
• É aceitável que o programa produza vários erros / avisos, que formam a fonte do programa quando concatenados juntos. Não é aceitável emitir erros / avisos que não aparecem na fonte.
• Diferente de muitos desafios, as opções fornecidas ao compilador e o nome do arquivo do programa provavelmente são altamente relevantes nesse desafio. Dado que o desafio pode não ser possível de outra forma, estou disposto a ser flexível aqui, embora, se você executar a implementação de uma maneira incomum, lembre-se de que as regras do PPCG cobram uma penalidade de bytes por fazê-lo (igual ao número de caracteres adicionais que você precisará adicionar na linha de comando a maneira mais curta e "normal" de executar um programa) e, assim, especificar o tamanho da penalidade em sua postagem. (Por exemplo, se o intérprete que você está usando lê o programa de um arquivo e não possui restrições específicas sobre o nome do arquivo, a maneira mais curta e normal de executar o programa seria de um arquivo com um nome de arquivo de 1 caractere; portanto,
• A versão do compilador / intérprete que você usa pode muito bem ser relevante; portanto, como parte do seu envio, indique um compilador ou intérprete específico no qual seu programa trabalha e qual versão é necessária. (Por exemplo, um envio em C pode indicar "C (gcc 6.2.0)" no cabeçalho.)
• Observe que essa tarefa pode não ser possível em todos os idiomas. Nos idiomas em que está, o método mais fácil provavelmente será encontrar uma mensagem de erro ou aviso para a qual é possível personalizar algum subconjunto do texto (alterando o nome de algo que é citado na mensagem; os nomes de arquivos são uma escolha comum aqui, mas não o único). Ficarei particularmente impressionado (e surpreso) se alguém encontrar uma maneira de fazer isso usando apenas mensagens de erro e aviso cujo texto foi corrigido.

Condição de vitória

Este é um desafio do código-golfe , portanto, uma entrada é considerada melhor se tiver uma contagem de bytes menor. Assim, depois que seu programa estiver funcionando, você deseja otimizá-lo para reduzir o número de bytes o máximo possível. (No entanto, não desanime se já houver uma entrada mais curta, especialmente se ela estiver em um idioma diferente; o que realmente estamos procurando aqui é reduzir o máximo possível um algoritmo ou uma ideia específica por trás de um programa, mas ver várias soluções em diferentes idiomas ou que se baseiam em princípios diferentes sempre vale a pena.)

JavaScript (Firefox 50), 153 bytes

Error: "Error: 1.replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})".replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})

Explicação

A idéia aqui era começar com o jine JS mais facilmente modificável que eu já encontrei:

".replace(/.+/,x=>alert(uneval(x)+x))".replace(/.+/,x=>alert(uneval(x)+x))

A throwpalavra-chave é uma maneira simples de fazer com que ela crie seu próprio código:

".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})

No entanto, há um pequeno problema: o Firefox anexa a mensagem lançada Error:. Felizmente, Error: mycodeé realmente JavaScript válido! (Para saber mais sobre isso, visite MDN .)

Error: ".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})Error: ".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})

Ops, isso alerta a coisa errada:

".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})Error: ".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})Error: 

Como as aspas não estão mais no início do código, uneval(x)+xnão nos dará o resultado correto. A melhor maneira de corrigir isso é adicionar um espaço reservado no lugar da sequência aninhada:

Error: "Error: 1.replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x})".replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x})

Agora, há um extra Error:na mensagem de erro. Vamos corrigir isso cortando a string:

Error: "Error: 1.replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})".replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})

E, finalmente, a saída e a mensagem de erro são idênticas ao código! Eu adicionaria um snippet de pilha, mas ele não parece funcionar em um snippet em nenhum navegador.

Python 2, 217 80 51 bytes

O avanço de linha à direita é necessário.

s='s=%r;print s%%s;exit(s%%s)';print s%s;exit(s%s)

Experimente online

Comecei com um quine simples:

s='s=%r;print s%%s';print s%s

Então eu adicionei raiseno final para jogar um IOError.

s='s=%r;print s%%s;raise IOError(s%%s)';print s%s;raise IOError(s%s)

Infelizmente, o traceback estava causando problemas (eu não conseguia fazê-lo desaparecer completamente), e o nome da exceção sempre era impresso na frente IOError: <code here>, como se eu removesse o traceback.

Então eu encontrei esta resposta útil para SO e a modifiquei para meus propósitos.

Então eu descobri que posso pular a criação de minha própria classe e simplesmente usá-la sys.exit, tornando meu código muito mais curto.