Package net.hydromatic.morel.compile

Class TypeResolver

java.lang.Object

net.hydromatic.morel.compile.TypeResolver

public class TypeResolver
extends java.lang.Object

Resolves the type of an expression.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	TypeResolver.BindTypeEnv	A type environment that consists of a type environment plus one binding.
private static class	TypeResolver.EmptySubst	Empty substitution.
(package private) static class	TypeResolver.EmptyTypeEnv	Empty type environment.
private static class	TypeResolver.PlusSubst	Substitution that adds one (type, variable) assignment to a parent substitution.
static class	TypeResolver.Resolved	Result of validating a declaration.
private static class	TypeResolver.Subst	Substitution.
private static class	TypeResolver.TermToTypeConverter	Visitor that converts type terms into actual types.
private static class	TypeResolver.TermVariable	Pair consisting of a term and a variable.
(package private) static interface	TypeResolver.TypeEnv	Type environment.
private class	TypeResolver.TypeEnvHolder	Contains a TypeResolver.TypeEnv and adds to it by calling TypeResolver.TypeEnv.bind(String, Function).
static class	TypeResolver.TypeMap	The result of type resolution, a map from AST nodes to types.

Field Summary

Fields

Modifier and Type	Field	Description
(package private) java.util.Map<Unifier.Variable,Unifier.Action>	actionMap
private static java.lang.String	APPLY_TY_CON
private static java.lang.String	FN_TY_CON
private static java.lang.String[]	INT_STRINGS
private static java.lang.String	LIST_TY_CON
(package private) java.util.Map<AstNode,Unifier.Term>	map
private static java.lang.String	RECORD_TY_CON
(package private) java.util.List<TypeResolver.TermVariable>	terms
private static java.lang.String	TUPLE_TY_CON
(package private) TypeSystem	typeSystem
(package private) java.util.Map<java.lang.String,TypeVar>	tyVarMap
(package private) Unifier	unifier

Constructor Summary

Constructors

Modifier	Constructor	Description
private	TypeResolver(TypeSystem typeSystem)

Method Summary

Modifier and Type	Method	Description
private static TypeResolver.TypeEnv	bindAll(TypeResolver.TypeEnv env, java.util.Map<Ast.IdPat,Unifier.Term> termMap)
private Ast.Exp	comparison(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v)	Registers an infix operator whose type is a given type and whose arguments are the same type.
private Ast.Exp	deduceConsType(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v)
private void	deduceDatatypeBindType(TypeResolver.TypeEnv env, Ast.DatatypeBind datatypeBind, java.util.Map<Ast.IdPat,Unifier.Term> termMap)
private Ast.Decl	deduceDeclType(TypeResolver.TypeEnv env, Ast.Decl node, java.util.Map<Ast.IdPat,Unifier.Term> termMap)
private void	deduceMatchListType(TypeResolver.TypeEnv env, java.util.List<Ast.Match> matchList, java.util.NavigableSet<java.lang.String> labelNames, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private AstNode	deduceMatchType(TypeResolver.TypeEnv env, Ast.Match match, java.util.Map<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Pat	deducePatType(TypeResolver.TypeEnv env, Ast.Pat pat, java.util.Map<Ast.IdPat,Unifier.Term> termMap, java.util.NavigableSet<java.lang.String> labelNames, Unifier.Variable v)	Derives a type term for a pattern, collecting the names of pattern variables.
private Ast.RecordSelector	deduceRecordSelectorType(TypeResolver.TypeEnv env, Unifier.Variable vResult, Unifier.Variable vArg, Ast.RecordSelector recordSelector)
static TypeResolver.Resolved	deduceType(Environment env, Ast.Decl decl, TypeSystem typeSystem)	Deduces the type of a declaration.
private Ast.Exp	deduceType(TypeResolver.TypeEnv env, Ast.Exp node, Unifier.Variable v)
private TypeResolver.Resolved	deduceType_(Environment env, Ast.Decl decl)
private AstNode	deduceValBindType(TypeResolver.TypeEnv env, Ast.ValBind valBind, java.util.Map<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable v)
private Ast.Decl	deduceValDeclType(TypeResolver.TypeEnv env, Ast.ValDecl valDecl, java.util.Map<Ast.IdPat,Unifier.Term> termMap)
private void	equiv(Unifier.Term term, Unifier.Term term2)
private void	equiv(Unifier.Term term, Unifier.Variable atom)
private static java.util.List<java.lang.String>	fieldList(Unifier.Sequence sequence)
private static Ast.Exp	idTuple(java.util.List<java.lang.String> vars)	Converts a list of variable names to a variable or tuple.
private Ast.Exp	infix(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v, Type type)	Registers an infix operator whose type is a given type.
private Ast.Exp	infixOverloaded(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v, Type defaultType)	Registers an infix or prefix operator whose type is the same as its arguments.
private boolean	isContiguousIntegers(java.util.NavigableSet<java.lang.String> names)	Returns whether a collection consists of ["1", "2", ...
private Ast.Exp	opOverloaded(TypeResolver.TypeEnv env, Ast.Exp call, Unifier.Variable v, Type defaultType)	Registers an infix or prefix operator whose type is the same as its arguments.
private Ast.Pat	patTuple(TypeResolver.TypeEnv env, java.util.List<Ast.Pat> patList)	Converts a list of patterns to a singleton pattern or tuple pattern.
private Ast.Exp	prefixOverloaded(TypeResolver.TypeEnv env, Ast.PrefixCall call, Unifier.Variable v, Type defaultType)	Registers an infix or prefix operator whose type is the same as its arguments.
private Unifier.Term	record(java.util.NavigableMap<java.lang.String,Unifier.Term> labelTypes)
private <E extends AstNode> E	reg(E node, Unifier.Variable variable, Unifier.Term term)
private static java.lang.String	str(int i)	Converts an integer to its string representation, using a cached value if possible.
private Unifier.Term	toTerm(PrimitiveType type)
private Unifier.Term	toTerm(Type type, TypeResolver.Subst subst)
private java.util.List<Unifier.Term>	toTerms(java.lang.Iterable<? extends Type> types, TypeResolver.Subst subst)
private Type	toType(Ast.Type type)
private java.util.List<Type>	toTypes(java.util.List<Ast.Type> typeList)
private Ast.ValBind	toValBind(TypeResolver.TypeEnv env, Ast.FunBind funBind)
private Ast.ValDecl	toValDecl(TypeResolver.TypeEnv env, Ast.FunDecl funDecl)	Converts a function declaration to a value declaration.
private Unifier.Sequence	tuple(java.util.List<Unifier.Term> types)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

typeSystem

final TypeSystem typeSystem

unifier

final Unifier unifier

terms

final java.util.List<TypeResolver.TermVariable> terms

map

final java.util.Map<AstNode,Unifier.Term> map

actionMap

final java.util.Map<Unifier.Variable,Unifier.Action> actionMap

tyVarMap

final java.util.Map<java.lang.String,TypeVar> tyVarMap

TUPLE_TY_CON

private static final java.lang.String TUPLE_TY_CON

See Also:

Constant Field Values

LIST_TY_CON

private static final java.lang.String LIST_TY_CON

See Also:

Constant Field Values

RECORD_TY_CON

private static final java.lang.String RECORD_TY_CON

See Also:

Constant Field Values

FN_TY_CON

private static final java.lang.String FN_TY_CON

See Also:

Constant Field Values

APPLY_TY_CON

private static final java.lang.String APPLY_TY_CON

See Also:

Constant Field Values

INT_STRINGS

private static final java.lang.String[] INT_STRINGS

Constructor Detail

TypeResolver

private TypeResolver(TypeSystem typeSystem)

Method Detail

deduceType

public static TypeResolver.Resolved deduceType(Environment env,
                                               Ast.Decl decl,
                                               TypeSystem typeSystem)

Deduces the type of a declaration.

deduceType_

private TypeResolver.Resolved deduceType_(Environment env,
                                          Ast.Decl decl)

reg

private <E extends AstNode> E reg(E node,
                                  Unifier.Variable variable,
                                  Unifier.Term term)

deduceType

private Ast.Exp deduceType(TypeResolver.TypeEnv env,
                           Ast.Exp node,
                           Unifier.Variable v)

record

private Unifier.Term record(java.util.NavigableMap<java.lang.String,Unifier.Term> labelTypes)

tuple

private Unifier.Sequence tuple(java.util.List<Unifier.Term> types)

isContiguousIntegers

private boolean isContiguousIntegers(java.util.NavigableSet<java.lang.String> names)

Returns whether a collection consists of ["1", "2", ... "n"].

str

private static java.lang.String str(int i)

Converts an integer to its string representation, using a cached value if possible.

deduceRecordSelectorType

private Ast.RecordSelector deduceRecordSelectorType(TypeResolver.TypeEnv env,
                                                    Unifier.Variable vResult,
                                                    Unifier.Variable vArg,
                                                    Ast.RecordSelector recordSelector)

fieldList

private static java.util.List<java.lang.String> fieldList(Unifier.Sequence sequence)

deduceMatchType

private AstNode deduceMatchType(TypeResolver.TypeEnv env,
                                Ast.Match match,
                                java.util.Map<Ast.IdPat,Unifier.Term> termMap,
                                Unifier.Variable argVariable,
                                Unifier.Variable resultVariable)

deduceMatchListType

private void deduceMatchListType(TypeResolver.TypeEnv env,
                                 java.util.List<Ast.Match> matchList,
                                 java.util.NavigableSet<java.lang.String> labelNames,
                                 Unifier.Variable argVariable,
                                 Unifier.Variable resultVariable)

deduceValBindType

private AstNode deduceValBindType(TypeResolver.TypeEnv env,
                                  Ast.ValBind valBind,
                                  java.util.Map<Ast.IdPat,Unifier.Term> termMap,
                                  Unifier.Variable v)

bindAll

private static TypeResolver.TypeEnv bindAll(TypeResolver.TypeEnv env,
                                            java.util.Map<Ast.IdPat,Unifier.Term> termMap)

deduceDeclType

private Ast.Decl deduceDeclType(TypeResolver.TypeEnv env,
                                Ast.Decl node,
                                java.util.Map<Ast.IdPat,Unifier.Term> termMap)

deduceValDeclType

private Ast.Decl deduceValDeclType(TypeResolver.TypeEnv env,
                                   Ast.ValDecl valDecl,
                                   java.util.Map<Ast.IdPat,Unifier.Term> termMap)

deduceDatatypeBindType

private void deduceDatatypeBindType(TypeResolver.TypeEnv env,
                                    Ast.DatatypeBind datatypeBind,
                                    java.util.Map<Ast.IdPat,Unifier.Term> termMap)

toType

private Type toType(Ast.Type type)

toTypes

private java.util.List<Type> toTypes(java.util.List<Ast.Type> typeList)

toValDecl

private Ast.ValDecl toValDecl(TypeResolver.TypeEnv env,
                              Ast.FunDecl funDecl)

Converts a function declaration to a value declaration. In other words, fun is syntactic sugar, and this is the de-sugaring machine.

For example, fun inc x = x + 1 becomes val rec inc = fn x => x + 1.

If there are multiple arguments, there is one fn for each argument: fun sum x y = x + y becomes val rec sum = fn x => fn y => x + y.

If there are multiple clauses, we generate case: fun gcd a 0 = a | gcd a b = gcd b (a mod b) becomes val rec gcd = fn x => fn y => case (x, y) of (a, 0) => a | (a, b) = gcd b (a mod b).

toValBind

private Ast.ValBind toValBind(TypeResolver.TypeEnv env,
                              Ast.FunBind funBind)

idTuple

private static Ast.Exp idTuple(java.util.List<java.lang.String> vars)

Converts a list of variable names to a variable or tuple.

For example, ["x"] becomes "x" (an Ast.Id), and ["x", "y"] becomes "(x, y)" (a Ast.Tuple of Ids).

patTuple

private Ast.Pat patTuple(TypeResolver.TypeEnv env,
                         java.util.List<Ast.Pat> patList)

Converts a list of patterns to a singleton pattern or tuple pattern.

deducePatType

private Ast.Pat deducePatType(TypeResolver.TypeEnv env,
                              Ast.Pat pat,
                              java.util.Map<Ast.IdPat,Unifier.Term> termMap,
                              java.util.NavigableSet<java.lang.String> labelNames,
                              Unifier.Variable v)

Derives a type term for a pattern, collecting the names of pattern variables.

Parameters:

env - Compile-time environment

pat - Pattern AST

termMap - Map from names to bound terms, populated by this method

labelNames - List of names of labels in this pattern and sibling patterns in a | match, or null if not a record pattern

v - Type variable that this method should equate the type term that it derives for this pattern

infix

private Ast.Exp infix(TypeResolver.TypeEnv env,
                      Ast.InfixCall call,
                      Unifier.Variable v,
                      Type type)

Registers an infix operator whose type is a given type.

comparison

private Ast.Exp comparison(TypeResolver.TypeEnv env,
                           Ast.InfixCall call,
                           Unifier.Variable v)

Registers an infix operator whose type is a given type and whose arguments are the same type.

infixOverloaded

private Ast.Exp infixOverloaded(TypeResolver.TypeEnv env,
                                Ast.InfixCall call,
                                Unifier.Variable v,
                                Type defaultType)

Registers an infix or prefix operator whose type is the same as its arguments.

prefixOverloaded

private Ast.Exp prefixOverloaded(TypeResolver.TypeEnv env,
                                 Ast.PrefixCall call,
                                 Unifier.Variable v,
                                 Type defaultType)

Registers an infix or prefix operator whose type is the same as its arguments.

opOverloaded

private Ast.Exp opOverloaded(TypeResolver.TypeEnv env,
                             Ast.Exp call,
                             Unifier.Variable v,
                             Type defaultType)

Registers an infix or prefix operator whose type is the same as its arguments.

deduceConsType

private Ast.Exp deduceConsType(TypeResolver.TypeEnv env,
                               Ast.InfixCall call,
                               Unifier.Variable v)

equiv

private void equiv(Unifier.Term term,
                   Unifier.Variable atom)

equiv

private void equiv(Unifier.Term term,
                   Unifier.Term term2)

toTerms

private java.util.List<Unifier.Term> toTerms(java.lang.Iterable<? extends Type> types,
                                             TypeResolver.Subst subst)

toTerm

private Unifier.Term toTerm(PrimitiveType type)

toTerm

private Unifier.Term toTerm(Type type,
                            TypeResolver.Subst subst)