Package net.hydromatic.morel.compile

Class Resolver

java.lang.Object

net.hydromatic.morel.compile.Resolver

public class Resolver
extends Object

Converts AST expressions to Core expressions.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private class	Resolver.FromResolver	Visitor that converts Ast.From to Core.From by handling each subtype of Ast.FromStep calling FromBuilder appropriately.
private static class	Resolver.Init	Helper for initialization.
(package private) static class	Resolver.PatExp	Pattern and expression.
(package private) static class	Resolver.ReferenceFinder	Visitor that finds all references to unbound variables in an expression.
(package private) static class	Resolver.ResolvedDatatypeDecl	Resolved datatype declaration.
static class	Resolver.ResolvedDecl	Resolved declaration.
(package private) class	Resolver.ResolvedValDecl	Resolved value declaration.

Field Summary

Fields

Modifier and Type	Field	Description
static com.google.common.collect.ImmutableMap<BuiltIn,Op>	BUILT_IN_OP_MAP	Map from BuiltIn, to Op; the reverse of OP_BUILT_IN_MAP, and needed when we convert an optimized expression back to human-readable Morel code.
private Environment	env
private NameGenerator	nameGenerator
static com.google.common.collect.ImmutableMap<Op,BuiltIn>	OP_BUILT_IN_MAP	Map from Op to BuiltIn.
(package private) TypeMap	typeMap
private Map<Pair<Core.NamedPat,Type>,Core.NamedPat>	variantIdMap	Contains variable declarations whose type at the point they are used is different (more specific) than in their declaration.

Constructor Summary

Constructors

Modifier	Constructor	Description
private	Resolver(TypeMap typeMap, NameGenerator nameGenerator, Map<Pair<Core.NamedPat,Type>,Core.NamedPat> variantIdMap, Environment env)

Method Summary

Modifier and Type	Method	Description
private void	flatten(Map<Ast.Pat,Ast.Exp> matches, boolean flatten, Ast.Pat pat, Ast.Exp exp)
private Core.Exp	flattenLet(List<Ast.Decl> decls, Ast.Exp exp)
private Core.NamedPat	getIdPat(Ast.Id id, Binding binding)	Converts an Id that is a reference to a variable into an IdPat that represents its declaration.
static Resolver	of(TypeMap typeMap, Environment env)	Creates a root Resolver.
private boolean	references(List<Resolver.PatExp> patExps)	Returns whether any of the expressions in exps references and of the variables defined in pats.
private Resolver.ResolvedDecl	resolve(Ast.Decl decl, List<Binding> bindings)
private Resolver.ResolvedDatatypeDecl	resolveDatatypeDecl(Ast.DatatypeDecl decl, List<Binding> bindings)
private Resolver.ResolvedValDecl	resolveValDecl(Ast.ValDecl valDecl, List<Binding> bindings)
private BuiltIn	toBuiltIn(Op op)
private Core.Aggregate	toCore(Ast.Aggregate aggregate, Collection<? extends Core.IdPat> groupKeys)
private Core.Apply	toCore(Ast.Apply apply)
private Core.Case	toCore(Ast.Case case_)
private DataType	toCore(Ast.DatatypeBind bind)
Core.DatatypeDecl	toCore(Ast.DatatypeDecl datatypeDecl)
Core.Decl	toCore(Ast.Decl node)
private Core.Exp	toCore(Ast.Exp exp)
private Core.Fn	toCore(Ast.Fn fn)
(package private) Core.Exp	toCore(Ast.From from)
private Core.Id	toCore(Ast.Id id)
private Core.Case	toCore(Ast.If if_)
private Core.Apply	toCore(Ast.InfixCall call)
private Core.Exp	toCore(Ast.Let let)
private Core.Exp	toCore(Ast.ListExp list)
private Core.Match	toCore(Ast.Match match)
private Core.OrderItem	toCore(Ast.OrderItem orderItem)
private Core.Pat	toCore(Ast.Pat pat)
private Core.Pat	toCore(Ast.Pat pat, Type targetType)
private Core.Pat	toCore(Ast.Pat pat, Type type, Type targetType)	Converts a pattern to Core.
private Core.Tuple	toCore(Ast.Record record)
private Core.RecordSelector	toCore(Ast.RecordSelector recordSelector)
private Core.Tuple	toCore(Ast.Tuple tuple)
Core.ValDecl	toCore(Ast.ValDecl valDecl)	Converts a simple Ast.ValDecl, of the form val v = e, to a Core Core.ValDecl.
private Core.Exp	toCoreFromEq(Ast.Exp exp)	Translates "x" in "from e = x".
private Core.IdPat	toCorePat(Ast.Id id)	Converts an id in a declaration to Core.
private static <E,T> com.google.common.collect.ImmutableList<T>	transform(Iterable<? extends E> elements, Function<E,T> mapper)
Resolver	withEnv(Iterable<Binding> bindings)	Binds a Resolver to an environment that consists of the current environment plus some bindings.
Resolver	withEnv(Environment env)	Binds a Resolver to a new environment.

Methods inherited from class java.lang.Object

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

Field Detail

OP_BUILT_IN_MAP

public static final com.google.common.collect.ImmutableMap<Op,BuiltIn> OP_BUILT_IN_MAP

Map from Op to BuiltIn.

BUILT_IN_OP_MAP

public static final com.google.common.collect.ImmutableMap<BuiltIn,Op> BUILT_IN_OP_MAP

Map from BuiltIn, to Op; the reverse of OP_BUILT_IN_MAP, and needed when we convert an optimized expression back to human-readable Morel code.

typeMap

final TypeMap typeMap

nameGenerator

private final NameGenerator nameGenerator

env

private final Environment env

variantIdMap

private final Map<Pair<Core.NamedPat,Type>,Core.NamedPat> variantIdMap

Contains variable declarations whose type at the point they are used is different (more specific) than in their declaration.

For example, the infix operator "op +" has type "α * α →" in the base environment, but at point of use might instead be "int * int → int". This map will contain a new Core.IdPat for all points that use it with that second type. Effectively, it is a phantom declaration, in a let that doesn't exist. Without this shared declaration, all points have their own distinct Core.IdPat, which the Analyzer will think is used just once.

Constructor Detail

Resolver

private Resolver(TypeMap typeMap,
                 NameGenerator nameGenerator,
                 Map<Pair<Core.NamedPat,Type>,Core.NamedPat> variantIdMap,
                 Environment env)

Method Detail

of

public static Resolver of(TypeMap typeMap,
                          Environment env)

Creates a root Resolver.

withEnv

public Resolver withEnv(Environment env)

Binds a Resolver to a new environment.

withEnv

public final Resolver withEnv(Iterable<Binding> bindings)

Binds a Resolver to an environment that consists of the current environment plus some bindings.

transform

private static <E,T> com.google.common.collect.ImmutableList<T> transform(Iterable<? extends E> elements,
                                                                                Function<E,T> mapper)

toCore

public Core.Decl toCore(Ast.Decl node)

toCore

public Core.ValDecl toCore(Ast.ValDecl valDecl)

Converts a simple Ast.ValDecl, of the form val v = e, to a Core Core.ValDecl.

Declarations such as val (x, y) = (1, 2) and val emp :: rest = emps are considered complex, and are not handled by this method.

Likewise recursive declarations.

toCore

public Core.DatatypeDecl toCore(Ast.DatatypeDecl datatypeDecl)

resolve

private Resolver.ResolvedDecl resolve(Ast.Decl decl,
                                      List<Binding> bindings)

resolveDatatypeDecl

private Resolver.ResolvedDatatypeDecl resolveDatatypeDecl(Ast.DatatypeDecl decl,
                                                          List<Binding> bindings)

resolveValDecl

private Resolver.ResolvedValDecl resolveValDecl(Ast.ValDecl valDecl,
                                                List<Binding> bindings)

references

private boolean references(List<Resolver.PatExp> patExps)

Returns whether any of the expressions in exps references and of the variables defined in pats.

This method is used to decide whether it is safe to convert a recursive declaration into a non-recursive one.

toCore

private DataType toCore(Ast.DatatypeBind bind)

toCore

private Core.Exp toCore(Ast.Exp exp)

toCore

private Core.Id toCore(Ast.Id id)

toCorePat

private Core.IdPat toCorePat(Ast.Id id)

Converts an id in a declaration to Core.

getIdPat

private Core.NamedPat getIdPat(Ast.Id id,
                               Binding binding)

Converts an Id that is a reference to a variable into an IdPat that represents its declaration.

toCore

private Core.Tuple toCore(Ast.Tuple tuple)

toCore

private Core.Tuple toCore(Ast.Record record)

toCore

private Core.Exp toCore(Ast.ListExp list)

toCoreFromEq

private Core.Exp toCoreFromEq(Ast.Exp exp)

Translates "x" in "from e = x". Desugar to the same as if they had written "from e in [x]".

toCore

private Core.Apply toCore(Ast.Apply apply)

toCore

private Core.RecordSelector toCore(Ast.RecordSelector recordSelector)

toCore

private Core.Apply toCore(Ast.InfixCall call)

toBuiltIn

private BuiltIn toBuiltIn(Op op)

toCore

private Core.Fn toCore(Ast.Fn fn)

toCore

private Core.Case toCore(Ast.If if_)

toCore

private Core.Case toCore(Ast.Case case_)

toCore

private Core.Exp toCore(Ast.Let let)

flattenLet

private Core.Exp flattenLet(List<Ast.Decl> decls,
                            Ast.Exp exp)

flatten

private void flatten(Map<Ast.Pat,Ast.Exp> matches,
                     boolean flatten,
                     Ast.Pat pat,
                     Ast.Exp exp)

toCore

private Core.Pat toCore(Ast.Pat pat)

toCore

private Core.Pat toCore(Ast.Pat pat,
                        Type targetType)

toCore

private Core.Pat toCore(Ast.Pat pat,
                        Type type,
                        Type targetType)

Converts a pattern to Core.

Expands a pattern if it is a record pattern that has an ellipsis or if the arguments are not in the same order as the labels in the type.

toCore

private Core.Match toCore(Ast.Match match)

toCore

Core.Exp toCore(Ast.From from)

toCore

private Core.Aggregate toCore(Ast.Aggregate aggregate,
                              Collection<? extends Core.IdPat> groupKeys)

toCore

private Core.OrderItem toCore(Ast.OrderItem orderItem)