Ruby Type Inference - Home

Idea: Patch up with lint/checkr

2007-02-22T03:05:00Z

Idea: Patch up with lint/checkr

Ruby Hacking Guide

2007-02-21T20:43:00Z

"Ruby Hacking Guide":http://rhg.rubyforge.org/

TI in Nemerle

2007-02-16T22:27:00Z

Type Inference in Nemerle, F/OO .NET lang. "Type Inference with Deferral":http://nemerle.org/Type_inference

IDE Cursor Position "Gate Point"

2007-02-16T21:55:00Z

Regarding error handling, it occurred we likely have a gate point at which extra node “doctoring” will need to take place in the case of malformed source when invoking TI for completion in an IDE; namely, the cursor location at the time of inference. This may be a big help to the error recovery algorithm?

DDP: Demand-Driven Analysis with Goal Pruning

2007-02-16T21:55:00Z

Lex Spoon has some rockin’ ideas ! I know I will very likely take many pages from this approach, just documenting it here for posterity ; )

Error Handling in Parsing

2007-02-16T21:49:00Z

Ones I have looked through briefly:

Burke-Fisher: A Practical Method for LR and LL Syntactic Error Diagnosis and Recovery

Great ideas, solid grounding for graceful handling of error diag.

LR(k) Error Diagnosis and Recovery from Jikes

Updates on Burke-Fisher, focuses on LR(k), provides a more performant algorithm.

Ones I have looked through not so much:

ANTLR error handling and recovery

ANTLR 3.0 Error Handling TJP notes

Fast, Error Correcting Parser Combinators: A Short Tutorial

Graceful Error Recovery @ LTU

Lex, Yacc, error symbols, tutorial style: Introduction to Compiler Construction With Unix

JavaCC – Syntax Error Repair for a Javabased Parser Generator

Gradual Typing for Objects

2007-02-16T21:49:00Z

Gradual Typing for Objects (via LtU).

Ruby Grammarians thread

2007-02-16T21:46:00Z

A bit of inquiry over at ruby-grammarians yielded some great leads.

Agenda

2007-02-16T21:44:00Z

Goal: To design and implement type inference for Ruby geared towards code completion in an IDE. The tool should:

Work via static analysis
Accept invalid/partial source
Provide an open interface (observer to IDE source changes, etc., but not be impossible to hook up to a command line interface for other static analysis uses)
Be reasonably performant (whatever that means)

It will likely be demand driven and constraints based.

It will likely be written in Java with the intent of integrating to RDT (see Summer of Code work), with experiments in Ruby.

This (hacking algorithms in both Ruby and Java) may be made easier by using an ANTLR grammar now that ANTLR3 can target Ruby as well as Java. The Rubyfront/XRuby grammar is a great candidate.

Alternatively, parse.y is viable through Jay and/or Racc.