Type information in Abstract Syntax Trees

Question

What type information exists in an abstract syntax tree? How are ASTs used for type inferencing? I don't understand how type input and output can be derived given an AST when none of the nodes indicate the concrete types. Are the types inferred from the tree structure alone? e.g. There are a bunch of IfStatement(Statement), so it's likely to return a bool? For example, the javalang python module uses these AST nodes:

CompilationUnit(Node)
Import(Node)
Documented(Node)
Declaration(Node)
Type(Node)
TypeArgument(Node)
TypeParameter(Node)
Annotation(Node)
ElementValuePair(Node)
ElementArrayValue(Node)
ArrayInitializer(Node)
VariableDeclarator(Node)
InferredFormalParameter(Node)
Statement(Node)
SwitchStatementCase(Node)
ForControl(Node)
EnhancedForControl(Node)
Expression(Node)
EnumBody(Node)
VariableDeclaration(Declaration)
FormalParameter(Declaration)
TryResource(Declaration)
CatchClauseParameter(Declaration)
AnnotationMethod(Declaration)
BasicType(Type)
ReferenceType(Type)
TypeDeclaration(Declaration, Documented)
PackageDeclaration(Declaration, Documented)
ConstructorDeclaration(Declaration, Documented)
EnumConstantDeclaration(Declaration, Documented)
ClassDeclaration(TypeDeclaration)
EnumDeclaration(TypeDeclaration)
InterfaceDeclaration(TypeDeclaration)
AnnotationDeclaration(TypeDeclaration)
Member(Documented)
MethodDeclaration(Member, Declaration)
FieldDeclaration(Member, Declaration)
ConstantDeclaration(FieldDeclaration)
LocalVariableDeclaration(VariableDeclaration)
IfStatement(Statement)
WhileStatement(Statement)
DoStatement(Statement)
ForStatement(Statement)
AssertStatement(Statement)
BreakStatement(Statement)
ContinueStatement(Statement)
ReturnStatement(Statement)
ThrowStatement(Statement)
SynchronizedStatement(Statement)
TryStatement(Statement)
SwitchStatement(Statement)
BlockStatement(Statement)
StatementExpression(Statement)
CatchClause(Statement)
Assignment(Expression)
TernaryExpression(Expression)
BinaryOperation(Expression)
Cast(Expression)
MethodReference(Expression)
LambdaExpression(Expression)
Primary(Expression)
ArraySelector(Expression)
Literal(Primary)
This(Primary)
MemberReference(Primary)
Invocation(Primary)
SuperMemberReference(Primary)
ClassReference(Primary)
Creator(Primary)
ExplicitConstructorInvocation(Invocation)
SuperConstructorInvocation(Invocation)
MethodInvocation(Invocation)
SuperMethodInvocation(Invocation)
VoidClassReference(ClassReference)
ArrayCreator(Creator)
ClassCreator(Creator)
InnerClassCreator(Creator)

Given some toy code, it spits out the following AST for the functions:

public class HelloWorld{
  public static void main(String args[]){
     add(5);
  } 
  public static int add(int x){
     return x+0;
  }
}

(MethodDeclaration 
    (FormalParameter
        (ReferenceType)
    )
    (StatementExpression
        (MethodInvocation
            (Literal)
        )
    )
)

Also if anyone could point me to some good reading material on type inferencing given ASTs. Thanks.

Answer 1

How are ASTs used for type inferencing?

Type inference converts an untyped AST into a typed AST by traversing the tree propagating an "environment" that is a dictionary mapping variable names (including functions) to their types. This is propagated down the AST to the leaves.

The type of a literal integer or string is int or string.

The type of a variable is looked up in the environment.

The type of a function application f(x) where f: a -> b and x: a is b.

The type of fun x -> y where x: a and y: b is a -> b.

At a let x = y in z where y: a, inference adds a binding x: a to the environment and infers the type of z (which is the type of the entire let expression) in the context of that new environment so it can lookup x: a when it encounters x.

And so on. The Hindley-Milner type system is more complicated because it includes generics but the implementation is little more than doing this to obtain a sequence of constraints about type variables and solving those constraints to work out as many type variables as possible. Type variables are usually generalized at let bindings so, for example, let id x = x defines a generic identity function ∀a id: a -> a.

Also, in the presence of mutation, type variables originating from expansive types are not generalised so, for example, ref None: '_a has a weak polymorphic type denoted '_a in OCaml meaning "this type variable can only be resolved to one concrete type", i.e. ∃a rather than ∀x.

Type inference for a minimal ML dialect with int and fun is under 100 lines of code and just a reasonable implementation is fast on modern computers.

You might appreciate the following links:

• https://pfudke.wordpress.com/2014/11/20/hindley-milner-type-inference-a-practical-example-2/
• http://okmij.org/ftp/ML/generalization.html
• http://okmij.org/ftp/Haskell/AlgorithmsH.html#teval
• http://www.cs.cornell.edu/courses/cs6110/2013sp/lectures/lec32-sp13.pdf
• https://www.doc.ic.ac.uk/~scd/icooolps15_GC.pdf
• http://janvitek.org/pubs/oopsla17a.pdf
• http://www.cs.columbia.edu/~sedwards/classes/2016/4115-spring/proposals/JSJS.pdf
• https://github.com/7sharp9/write-you-an-inference-in-fsharp
• https://people.eecs.berkeley.edu/~wkahan/LOG10HAF.TXT
• http://www.elsman.com/pdf/masters.pdf
• https://courses.cs.washington.edu/courses/csep505/03au/hw/hw1.html
• http://lucacardelli.name/Papers/BasicTypechecking.pdf
• http://okmij.org/ftp/ML/generalization.html
• http://www.smlnj.org/doc/Conversion/types.html