Intellisense para lenguajes dinámicos

Question

Estoy buscando diversos enfoques para admitir cierto nivel de intellisense en un lenguaje de tipado dinámico. Como la información de intellisense se basa en información de tipo, existen dificultades inherentes en la implementación de esto para los lenguajes dinámicos.

¿Conoces algún algoritmo o método para implementarlo?

Answer 1

Es necesario escribir un abstracta intérprete que ejecuta el código con valores de tipo. Entonces, pisa con tu intérprete abstracto a través del AST y registra para cada variable los mensajes enviados o los tipos conocidos. Y cuando haya terminado, inferirá los tipos posibles utilizando la equivalencia de tipo estructural (también conocida como pato).

PS:además de la inferencia de tipos es posible que desee echar un vistazo a "How Program History Can Improve Code Completion" by Romain Robbes, es explica cómo mejorar aún más la terminación automática en los lenguajes dinámicos con información más utilizados más recientemente, y el filtrado colaborativo.

Así que aquí es cómo la interpretación abstracta que funciona para un fragmento de código como

def groups(array,&block) 
    groups = Hash.new 
    array.each { |ea| 
    key = block.call(ea) 
    groups[key] = [] unless groups.include? key 
    groups[key] << ea 
    } 
    return groups 
end 

sería empezar con

array = { :messages => [], :types => [] } 
block = { :messages => [], :types => [] } 

y luego

array = { :messages => [], :types => [] } 
block = { :messages => [], :types => [] } 
groups = { :messages => [], :types => [Hash] } 

y luego

array = { :messages => [:each], :types => [] } 
block = { :messages => [], :types => [] } 
groups = { :messages => [], :types => [Hash] } 

y luego

array = { :messages => [:each], :types => [] } 
block = { :messages => [:call], :types => [] } 
groups = { :messages => [], :types => [Hash] } 
key = { :messages => [], :types => [] } 

y luego

array = { :messages => [:each], :types => [] } 
block = { :messages => [:call], :types => [] } 
groups = { :messages => [:include?,:[]], :types => [Hash] } 
group_elements = { :messages => [], :types => [Array] } 
key = { :messages => [], :types => [] } 

y luego

array = { :messages => [:each], :types => [] } 
block = { :messages => [:call], :types => [] } 
groups = { :messages => [:include?,:[]], :types => [Hash] } 
group_elements = { :messages => [:<<], :types => [Array] } 
key = { :messages => [], :types => [] } 

por lo que finalmente se puede inferir que

• array es posiblemente un Enumerable
• block es posiblemente un Proc
• groups es una Hash con Array elementos
• key es cualquier objeto

Answer 2

Fácil, solo se debe agregar un paso adicional: type inference. Después de eso, conoces el tipo de información y puedes sugerirle algo al usuario.

Answer 3

Tenga en cuenta que un "lenguaje dinámico" y un "lenguaje de tipado dinámico" no son necesariamente lo mismo.

La forma en que Microsoft maneja esto en el intellisense para Javascript (VS2008) es que infiere, en la medida de sus posibilidades, qué tipo contiene actualmente la var. Si/cuando esto cambia, las siguientes referencias a la var presentarán opciones para el tipo actualizado.

Answer 4

Me gustaría descargar las fuentes del Groovy plugin para Eclipse, que tiene intelisense (lo más posible), y piensan Groovy es un buen ejemplo de un lenguaje Dyanamic con tipado dinámico