(Inspirado por este comentario sobre una vieja pregunta).

Antecedentes

Un error quine (también conocido como "Kimian quine") es un programa que, cuando se compila o ejecuta, hace que el compilador / intérprete / tiempo de ejecución imprima un mensaje de error que tiene un texto idéntico al programa en sí, y nada más. Para los propósitos de este desafío, estamos definiendo "error" en términos generales, para incluir advertencias también.

Tarea

En este desafío, estamos buscando una quine que también sea una quine de error. Cuando se ejecuta, el programa debe imprimir su propio código fuente normalmente (es decir, no como un mensaje de error / advertencia); Esto debe ser una cantidad adecuada (es decir, una parte del programa debe codificar una parte diferente de la salida). Además, compilar y ejecutar el programa también debe hacer que la implementación imprima el código fuente del programa, y ​​nada más, como mensajes de error o advertencia. (Tenga en cuenta que esto significa que no podrá utilizar errores en tiempo de compilación, en idiomas en los que impidan que el programa se ejecute normalmente). En otras palabras, el código fuente del programa se imprimirá dos veces, una por cada método.

Aclaraciones

• En la mayoría de los casos, será obvio qué es y qué no es un mensaje de error / advertencia; No estamos distinguiendo entre los dos aquí. En casos ambiguos, defina un mensaje de error / advertencia como cualquier texto generado por la implementación, ya sea: 1. como consecuencia de algo que no sea ejecutar un comando (o el equivalente más cercano en el idioma); o 2. eso no era parte de la entrada al comando que lo produjo como salida.
• La parte de error / advertencia de la quine no necesita ser una quine adecuada (aunque en la mayoría de los casos será por casualidad, ya que la mayoría de los mensajes de error y advertencia contienen cantidades considerables de texto fijo).
• Es aceptable que el programa genere múltiples errores / advertencias, que forman la fuente del programa cuando se concatenan juntos. No es aceptable generar errores / advertencias que no aparecen en la fuente.
• A diferencia de muchos desafíos, es probable que los cambios dados al compilador y el nombre del archivo del programa sean muy relevantes en este desafío. Dado que el desafío puede no ser posible de lo contrario, estoy dispuesto a ser flexible aquí, aunque si ejecuta la implementación de una manera inusual, recuerde que las reglas PPCG cobran una penalización de byte por hacerlo (igual a la cantidad de caracteres adicionales que deberías agregar en la línea de comando la forma más corta "normal" de ejecutar un programa) y, por lo tanto, deberás especificar el tamaño de la penalización en tu publicación. (Por ejemplo, si el intérprete que está utilizando lee el programa desde un archivo y no tiene restricciones particulares sobre el nombre del archivo, la forma más corta de ejecutar el programa sería desde un archivo con un nombre de archivo de 1 carácter; por lo tanto,
• La versión del compilador / intérprete que utilice puede ser relevante, por lo que, como parte de su envío, indique un compilador o intérprete específico en el que funciona su programa y qué versión se requiere. (Por ejemplo, un envío en C puede indicar "C (gcc 6.2.0)" en el encabezado).
• Tenga en cuenta que esta tarea puede no ser posible en todos los idiomas. En los idiomas donde está, el método más fácil probablemente sea encontrar un mensaje de error o advertencia para el que sea posible personalizar algún subconjunto del texto (cambiando el nombre de algo que se cita en el mensaje; los nombres de archivo son una opción común) aquí, pero no el único). Estaré particularmente impresionado (y sorprendido) si alguien encuentra una manera de hacer esto usando solo mensajes de error y advertencia cuyo texto es fijo.

Condición de victoria

Este es un desafío de código de golf , por lo que una entrada se considera mejor si tiene un recuento de bytes más pequeño. Como tal, una vez que tenga su programa funcionando, desea optimizarlo para reducir la cantidad de bytes lo más posible. (Sin embargo, no se desanime si ya hay una entrada más corta, especialmente si está en un idioma diferente; lo que realmente estamos buscando aquí es acortar un algoritmo o idea en particular detrás de un programa tanto como sea posible, pero viendo múltiples soluciones en diferentes idiomas o que se basan en principios diferentes siempre vale la 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)})

Explicación

La idea aquí era comenzar con la JS quine más fácilmente modificable que he encontrado hasta ahora:

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

La throwpalabra clave es una forma simple de hacer que también arroje su propio código:

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

Sin embargo, hay un pequeño problema: Firefox antepone el mensaje lanzado Error:. Afortunadamente, Error: mycodees realmente válido JavaScript! (Para obtener más información sobre esto, visite MDN ).

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

Vaya, esto alerta lo incorrecto:

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

Dado que las comillas ya no se encuentran al comienzo del código, uneval(x)+xno nos dará el resultado correcto. La mejor manera de solucionar esto es agregar un marcador de posición en lugar de la cadena anidada:

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})

Uh-oh, ahora hay un extra Error:en el mensaje de error. Arreglemos eso cortando la cadena:

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)})

Y finalmente, ¡tanto la salida como el mensaje de error son idénticos al código! Agregaría un fragmento de pila, pero no parece funcionar en un fragmento en ningún navegador.

Python 2, 217 80 51 bytes

Se requiere el avance de línea final.

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

Pruébalo en línea

Comencé con una simple quine:

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

Luego agregué raiseal final para lanzar un IOError.

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

Desafortunadamente, el rastreo estaba causando problemas (no pude hacer que desapareciera por completo), y el nombre de la excepción siempre se imprimió al frente como IOError: <code here>, incluso si eliminé el rastreo.

Luego encontré esta útil respuesta SO y la modifiqué para mis propósitos.

Luego descubrí que puedo omitir la creación de mi propia clase y simplemente puedo usar sys.exit, haciendo que mi código sea mucho más corto.