Package net.hydromatic.morel.compile

Class TypeResolver

java.lang.Object

net.hydromatic.morel.compile.TypeResolver

public class TypeResolver
extends 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.DatatypeBindWorkspace	Workspace used while handling several datatype binds simultaneously.
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.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.TypeException	Error while deducing type.

Field Summary

Fields

Modifier and Type	Field	Description
private Map<Unifier.Variable,Unifier.Action>	actionMap
(package private) static String	APPLY_TY_CON
(package private) static String	FN_TY_CON
(package private) static String	LIST_TY_CON
private Map<AstNode,Unifier.Term>	map
private List<Pair<Unifier.Variable,PrimitiveType>>	preferredTypes
(package private) static String	RECORD_TY_CON
private List<TypeResolver.TermVariable>	terms
(package private) static String	TUPLE_TY_CON
private TypeSystem	typeSystem
private Map<String,TypeVar>	tyVarMap
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, Map<Ast.IdPat,Unifier.Term> termMap)
private void	deduceDatatypeBindType(TypeResolver.TypeEnv env, Ast.DatatypeBind datatypeBind, Map<Ast.IdPat,Unifier.Term> termMap, TypeResolver.DatatypeBindWorkspace w)
private Ast.Decl	deduceDataTypeDeclType(TypeResolver.TypeEnv env, Ast.DatatypeDecl datatypeDecl, Map<Ast.IdPat,Unifier.Term> termMap)
private Ast.Decl	deduceDeclType(TypeResolver.TypeEnv env, Ast.Decl node, Map<Ast.IdPat,Unifier.Term> termMap)
private List<Ast.Match>	deduceMatchListType(TypeResolver.TypeEnv env, List<Ast.Match> matchList, NavigableSet<String> labelNames, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Match	deduceMatchType(TypeResolver.TypeEnv env, Ast.Match match, Map<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Pat	deducePatType(TypeResolver.TypeEnv env, Ast.Pat pat, Map<Ast.IdPat,Unifier.Term> termMap, NavigableSet<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)
private Pair<TypeResolver.TypeEnv,Unifier.Variable>	deduceStepType(TypeResolver.TypeEnv env, Ast.FromStep step, Unifier.Variable v, TypeResolver.TypeEnv env2, Map<Ast.Id,Unifier.Variable> fieldVars, List<Ast.FromStep> fromSteps)
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, Map<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable v, Unifier.Variable vPat)
private Ast.Decl	deduceValDeclType(TypeResolver.TypeEnv env, Ast.ValDecl valDecl, Map<Ast.IdPat,Unifier.Term> termMap)
private void	equiv(Unifier.Term term, Unifier.Term term2)
private void	equiv(Unifier.Term term, Unifier.Variable atom)
(package private) static List<String>	fieldList(Unifier.Sequence sequence)
private Unifier.Term	fieldRecord(Map<Ast.Id,Unifier.Variable> fieldVars)
private static Ast.Exp	idTuple(List<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)	Registers an infix operator.
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.Pat	patTuple(TypeResolver.TypeEnv env, List<Ast.Pat> patList)	Converts a list of patterns to a singleton pattern or tuple pattern.
private Ast.Exp	prefix(TypeResolver.TypeEnv env, Ast.PrefixCall call, Unifier.Variable v)	Registers a prefix operator.
private Unifier.Term	record(NavigableMap<String,? extends Unifier.Term> labelTypes)
private <E extends AstNode> E	reg(E node, Unifier.Variable variable, Unifier.Term term)
private Unifier.Term	toTerm(PrimitiveType type)
private Unifier.Term	toTerm(Type type, TypeResolver.Subst subst)
private List<Unifier.Term>	toTerms(Iterable<? extends Type> types, TypeResolver.Subst subst)
private Type	toType(Ast.Type type)
static Type	toType(Ast.Type type, TypeSystem typeSystem)	Converts a type AST to a type.
private List<Type>	toTypes(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.Term	tuple(List<Unifier.Term> types)
private void	validateGroup(Ast.Group group)	Validates a Group.

Methods inherited from class java.lang.Object

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

Field Detail

typeSystem

private final TypeSystem typeSystem

unifier

private final Unifier unifier

terms

private final List<TypeResolver.TermVariable> terms

map

private final Map<AstNode,Unifier.Term> map

actionMap

private final Map<Unifier.Variable,Unifier.Action> actionMap

tyVarMap

private final Map<String,TypeVar> tyVarMap

preferredTypes

private final List<Pair<Unifier.Variable,PrimitiveType>> preferredTypes

TUPLE_TY_CON

static final String TUPLE_TY_CON

See Also:

Constant Field Values

LIST_TY_CON

static final String LIST_TY_CON

See Also:

Constant Field Values

RECORD_TY_CON

static final String RECORD_TY_CON

See Also:

Constant Field Values

FN_TY_CON

static final String FN_TY_CON

See Also:

Constant Field Values

APPLY_TY_CON

static final String APPLY_TY_CON

See Also:

Constant Field Values

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.

toType

public static Type toType(Ast.Type type,
                          TypeSystem typeSystem)

Converts a type AST to a type.

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)

deduceStepType

private Pair<TypeResolver.TypeEnv,Unifier.Variable> deduceStepType(TypeResolver.TypeEnv env,
                                                                         Ast.FromStep step,
                                                                         Unifier.Variable v,
                                                                         TypeResolver.TypeEnv env2,
                                                                         Map<Ast.Id,Unifier.Variable> fieldVars,
                                                                         List<Ast.FromStep> fromSteps)

validateGroup

private void validateGroup(Ast.Group group)

Validates a Group. Throws if there are duplicate names among the keys and aggregates.

fieldRecord

private Unifier.Term fieldRecord(Map<Ast.Id,Unifier.Variable> fieldVars)

record

private Unifier.Term record(NavigableMap<String,? extends Unifier.Term> labelTypes)

tuple

private Unifier.Term tuple(List<Unifier.Term> types)

deduceRecordSelectorType

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

fieldList

static List<String> fieldList(Unifier.Sequence sequence)

deduceMatchType

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

deduceMatchListType

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

deduceValBindType

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

bindAll

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

deduceDeclType

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

deduceDataTypeDeclType

private Ast.Decl deduceDataTypeDeclType(TypeResolver.TypeEnv env,
                                        Ast.DatatypeDecl datatypeDecl,
                                        Map<Ast.IdPat,Unifier.Term> termMap)

deduceValDeclType

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

deduceDatatypeBindType

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

toType

private Type toType(Ast.Type type)

toTypes

private List<Type> toTypes(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(List<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,
                         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,
                              Map<Ast.IdPat,Unifier.Term> termMap,
                              NavigableSet<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.

infix

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

Registers an infix operator.

prefix

private Ast.Exp prefix(TypeResolver.TypeEnv env,
                       Ast.PrefixCall call,
                       Unifier.Variable v)

Registers a prefix operator.

equiv

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

equiv

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

toTerms

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

toTerm

private Unifier.Term toTerm(PrimitiveType type)

toTerm

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