//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
package hlt.language.design.kernel;
/**
* @version Last modified on Thu Mar 24 12:06:48 2016 by hak
* @author Hassan Aït-Kaci
* @copyright © by the author
*/
import hlt.language.design.types.*;
import hlt.language.design.instructions.*;
import hlt.language.util.Locatable;
import hlt.language.util.Location;
import hlt.language.util.Span;
import hlt.language.tools.Misc;
import java.util.HashSet;
import java.util.HashMap;
import java.util.Iterator;
/**
* This class is the mother of all expressions in the kernel language.
* It specifies the prototypes of the methods that must be implemented
* by all expression subclasses. The subclasses of Expression
* are:
*
*
*
*
* - Constant:
* constant (void, boolean, integer,
* real number,
* object);
*
*
- Abstraction:
* functional abstraction (à la lambda-calculus);
*
*
- Application:
* functional application;
*
*
- Local:
* local name;
*
*
- Global:
* global name;
*
*
- IfThenElse:
* conditional;
*
*
- AndOr:
* non-strict boolean conjunction and disjunction;
*
*
- Sequence:
* sequence of expressions (presumably with side-effects);
*
*
- Let:
* lexical scoping construct;
*
*
- Loop:
* conditional iteration construct;
*
*
- Definition:
* definition of a global name with an expression defining it
* in a global store;
*
*
- Parameter:
* a function's formal parameter (really a pseudo-expression
* as it is not fully processed as a real expression and is used
* as a shared type information repository for all occurrences
* in a function's body of the variable it stands for);
*
*
- Assignment:
* construct to set the value of a local
* or a global variable;
*
*
- NewObject:
* construct to create a new object;
*
*
- FieldUpdate:
* construct to update the value of an object's field;
*
*
- NewArray:
* construct to create a new (multidimensional) array;
*
*
- ArraySlot:
* construct to access the element of an array;
*
*
- ArraySlotUpdate:
* construct to update the element of an array;
*
*
- Tuple:
* construct to create a new position-indexed tuple;
*
*
- NamedTuple:
* construct to create a new name-indexed tuple;
*
*
- TupleProjection:
* construct to access the component of a tuple;
*
*
- TupleUpdate:
* construct to update the component of a tuple;
*
*
- Dummy:
* temporary place holder in lieu of a name prior to being discriminated
* into a local or global one.
*
* Typically, upon being read, an Expression will be:
*
*
*
*
* - "name-sanitized" - in the context of a Sanitizer to discriminate
* between local names and global names, and establish pointers from the
* local variable occurrences to the abstraction that introduces them,
* and from global names to entries in the global symbol table;
*
*
*
- type-checked - in the context of a TypeChecker to discover
* whether it has a type at all, or several possible ones (only
* expressions that have a unique unambiguous type are further
* processed);
*
*
*
- "sort-sanitized" - in the context of a Sanitizer to discriminate
* between those local variables that are of primitive Java types
* (int or double) or of Object type (this is
* necessary because the set-up means to use unboxed values for primitive
* types for efficiency reasons); this second "sanitization" phase is
* also used to compute offsets for local names (i.e., so-called
* de Bruijn indices) for each type sort;
*
*
*
- compiled - in the context of a
* Compiler to generate the sequence of instructions whose
* execution in an appropriate runtime environment will evaluate the expression;
*
*
*
- executed - in the context of a
* Runtime to execute its sequence of instructions.
*
*
* */
public abstract class Expression implements Locatable
{
/**
* When this is true, all assignments have a void type (and return
* no value); otherwise, they have the same type as the assigned value (which is also
* the value they return). This is useful for, e.g., overloading the equal
* sign '=' to mean something else besign assignment depending on the type.
* The kernel expressions that are assigments are:
*
* Each of these will use this flag to alter they type-cehcking and compiling rules
* accordingly.
*/
public static boolean VOID_ASSIGNMENTS = false;
/**
* Returns a deep copy of this expression. The types are not not copied.
* NB: This is a convenience for building expressions that should be used
* exclusively before any processing (in particular sanitizing), is done on this
* expression.
*/
public abstract Expression copy ();
/**
* Returns a deep copy of this expression this and all its subexpressions share the
* same type as their copy's counterparts. NB: This is a convenience for
* building expressions that should be used exclusively before any processing (in
* particular sanitizing), is done on this expression.
*/
public abstract Expression typedCopy ();
/**
* Prevents type-checking this expression more than once.
*/
protected boolean _typeCheckLocked = false;
public final boolean typeCheckLocked ()
{
if (!_typeCheckLocked)
{
_typeCheckLocked = true;
return false;
}
return true;
}
/**
* Prevents setting the checked type for this expression more than once.
*/
protected boolean _setCheckedTypeLocked = false;
public final boolean setCheckedTypeLocked ()
{
if (!_setCheckedTypeLocked)
{
_setCheckedTypeLocked = true;
return false;
}
return true;
}
/**
* Returns true iff this expression is a slicing filter for the specified
* parameter.
*/
public boolean isSlicing (Tables tables, Parameter parameter)
{
return false;
}
/**
* Returns true iff this expression is a "hidden" slicing filter for the
* specified parameter; i.e., one that uses accessor projections rather than
* explicit tuple projections.
*/
public boolean isHiddenSlicing (Tables tables, Parameter parameter)
{
return false;
}
/**
* Returns true iff this expression is a selector filter for the specified
* parameter.
*/
public boolean isSelector (Tables tables, Parameter parameter)
{
return false;
}
public final boolean isEquality (Tables tables) throws UndefinedEqualityException
{
if (!(this instanceof Dummy || this instanceof Global))
return false;
return tables.isEquality(this instanceof Dummy
? ((Dummy)this).name()
: ((Global)this).name());
}
/**
* This contains any other types that may be redudantly ascribed to this
* expression prior to being type-checked. For example, a grammar constructing
* an expression from a concrete syntax may allow several types to be attached
* a single expression. The type-checker will then ensure that all these types
* are compatible, and can be reduced to a single consistent one.
*/
protected HashSet _otherTypes;
/**
* Returns true iff this expression is a
* Constant.
*/
public final boolean isConstant ()
{
return this instanceof Constant;
}
/**
* Returns true iff this expression denotes the constant void.
*/
public final boolean isVoid ()
{
return this == Constant.VOID;
}
/**
* Returns true iff this expression denotes the constant true.
*/
public boolean isTrue ()
{
return isConstant() && ((Constant)this).isTrue();
}
/**
* Returns true iff this expression denotes the constant false.
*/
public boolean isFalse ()
{
return isConstant() && ((Constant)this).isFalse();
}
/**
* Returns true iff this expression denotes the constant null.
*/
public boolean isNull ()
{
return isConstant() && ((Constant)this).isNull();
}
/**
* This method returns the current type of this expression. It will typically, but not
* necessarily, be the dereferenced value of a
* TypeParameter field. A notable exception is a
* Local since its type method will always return the type of the Parameter it stands for.
*/
public abstract Type type ();
/**
* This method forcibly sets this expression's type field, if it has one, to the
* specified type. It will be an empty method otherwise.
*/
public abstract void setType (Type type);
/**
* This method returns this expression's undereferenced type field if it has one. It
* will return null otherwise.
*/
public abstract Type typeRef ();
/**
* This method returns the final unambiguously checked type of this expression.
*/
public abstract Type checkedType ();
/**
* This method sets the final unambiguously checked type of this expression, possibly
* along with other final information that may be needed by the compiler for
* generating code.
*/
public abstract void setCheckedType ();
/**
* This method sets the final unambiguously checked type of this expression to the
* specified type. This is used when expression are synthesized on the fly after the
* type-checking phase and prior to the compiling phase.
*/
public abstract void setCheckedType (Type type);
/**
* Returns the expression resulting from substituting all the free occurrences
* of the parameters's names as specified by the given substitution.
*/
public Expression substitute (HashMap substitution)
{
if (!substitution.isEmpty())
for (int i=numberOfSubexpressions(); i-->0;)
setSubexpression(i,subexpression(i).substitute(substitution));
return this;
}
/**
* Returns this expression enclosing scope (if it has been computed by linkScopeTree);
* null otherwise.
*/
public Expression enclosingScope ()
{
return null;
}
/**
* The number of comprehensions nested inside this expression.
*/
protected int _nestedComprehensionCount;
/**
* Returns the number of comprehensions nested inside this expression.
*/
final int nestedComprehensionCount ()
{
return _nestedComprehensionCount;
}
protected boolean _scopeTreeIsLinked;
/**
* Visits all subexpressions to link up the scope tree of nested comprehensions.
* It also sets and returns the nummber of such nested comprehensions. This is
* invoked in Sanitizer before sanitizing
* an outermost expression.
*/
int linkScopeTree (Expression ancestor)
{
if (_scopeTreeIsLinked)
return _nestedComprehensionCount;
for (int i=numberOfSubexpressions(); i-->0;)
_nestedComprehensionCount += subexpression(i).linkScopeTree(ancestor);
_scopeTreeIsLinked = true;
return _nestedComprehensionCount;
}
/**
* Visits all subexpressions to desugar the patterens of comprehensions if any are nested.
*/
void desugarPatterns ()
{
if (_nestedComprehensionCount > 0)
for (int i=numberOfSubexpressions(); i-->0;)
subexpression(i).desugarPatterns();
}
/**
* If there are nested comprehensions, this visits all subexpressions to unnest
* comprehension filters.
*/
void unnestInnerFilters ()
{
if (_nestedComprehensionCount > 0)
for (int i=numberOfSubexpressions(); i-->0;)
subexpression(i).unnestInnerFilters();
}
/**
* Returns true iff the specified name occurs free in this expression.
*/
public boolean containsFreeName (String name)
{
for (int i=numberOfSubexpressions(); i-->0;)
if (subexpression(i).containsFreeName(name))
return true;
return false;
}
/**
* This method returns the actual expression corresponding to this one after
* eliminating all the Dummy expressions that occur
* in it where names where read. It takes as an argument the stack of parameters it
* encounters along the way of visiting all its components. A
* ParameterStack is simply a Stack of
* Parameter objects along with a method to retrieve the latest one with
* a given name.
*/
public Expression sanitizeNames (ParameterStack parameters)
{
for (int i=numberOfSubexpressions(); i-->0;)
setSubexpression(i,subexpression(i).sanitizeNames(parameters));
return this;
}
/**
* This method walks down the expression gathering information relating each Local object to the
* Scope containing the corresponding
* Parameter in its array of formal parameters. It takes as an argument
* an Enclosure, which is a Stack
* containing all Scopes encountered
* along the way, equipped with a method to compute all the information necessary in
* computing the local's offset.
*/
public void sanitizeSorts (Enclosure enclosure)
{
for (int i=numberOfSubexpressions(); i-->0;)
subexpression(i).sanitizeSorts(enclosure);
}
/**
* This methods visits this expression shifting the offset of all the Locals it encounters by the specified amount (per
* sort) as long as the offset it sees is referencing a parameter within the specified
* scope depth (per sort); This method is used when the compiler needs to
* synthesize an scope from an already typechecked expression (i.e., for
* currying or un/boxing - e.g., see the pad method below).
*/
public Expression shiftOffsets (int intShift, int realShift, int objectShift,
int intDepth, int realDepth, int objectDepth)
{
for (int i=numberOfSubexpressions(); i-->0;)
setSubexpression(i,subexpression(i).shiftOffsets(intShift,realShift,objectShift,
intDepth,realDepth,objectDepth));
return this;
}
public final Expression shiftOffsets (int intShift, int realShift, int objectShift)
{
return shiftOffsets(intShift,realShift,objectShift,0,0,0);
}
/**
* This method type-checks this expression in the context of the specified
* TypeChecker.
*/
public abstract void typeCheck (TypeChecker typeChecker) throws TypingErrorException;
/**
* This method ascertains that this expression has the specified type in
* the context of the specified
* TypeChecker. It amounts to first type-checking this
* expression in the type-checker, then making sure the type found for it
* by the type-checker agrees (i.e.unifies) with the specified type.
*/
public void typeCheck (Type type, TypeChecker typeChecker) throws TypingErrorException
{
typeChecker.unify(typeRef(),type,this);
typeCheck(typeChecker);
}
/**
* This method type-checks this expression in the context of the specified typechecker,
* using the type of the specified Global as a filter.
*/
public final void typeCheck (Global filter, TypeChecker typeChecker) throws TypingErrorException
{
typeCheck(typeChecker);
typeChecker.prune(filter,typeRef(),this);
filter.typeCheck(typeRef(),typeChecker);
}
/**
* This method compiles this expression in the context of the specified
* Compiler.
*/
public abstract void compile (Compiler compiler);
/**
* Returns the number of subexpressions
*/
public int numberOfSubexpressions ()
{
return 0;
}
/**
* Returns the n-th subexpression of this expression; if there is no subexpression
* at the given position, this throws a NoSuchSubexpressionException
*/
public Expression subexpression (int n) throws NoSuchSubexpressionException
{
throw new NoSuchSubexpressionException(this,n);
}
/**
* Returns this expression after setting its n-th subexpression to the specified
* expression; if there is no subexpression at the given position, this throws a
* NoSuchSubexpressionException
*/
public Expression setSubexpression (int n, Expression expression) throws NoSuchSubexpressionException
{
return this;
}
/**
* This is only to enable uniform visitors on expressions. It will return non-null
* only for scopes.
*/
public Parameter[] parameters ()
{
return null;
}
/**
* Returns the sort of this expression's type after it has been
* checked. Sorts are of three kinds and defined as global constants
* in Type: Type.INT_SORT,
* Type.REAL_SORT, and Type.OBJECT_SORT.
*/
public final byte sort ()
{
return checkedType().sort();
}
/**
* This returns the runtime sort for this expression unless its type
* has been marked as boxed - in which case it returns OBJECT_SORT.
*/
public /* final */ byte boxSort ()
{
return checkedType().boxSort();
}
/**
* This adds the specified type as another type for this expression. NB:
* This method must never be used on an expression, or with a type, that
* has been (even partially) type-checked. This is because, rather than making
* different type parameters separate types for this expression, it hard-binds
* them together or to the original type if there is one. It is meant to be used
* exclusively at expression construction time prior to type-checking anything.
*/
public final Expression addType (Type newType)
{
Type oldType = type();
if (newType == null)
return this;
if (oldType == null)
setType(newType);
else
{
oldType = oldType.value();
newType = newType.value();
if (oldType == newType)
return this;
if (oldType.kind() == Type.PARAMETER)
((TypeParameter)oldType).bind(newType);
else
if (newType.kind() == Type.PARAMETER)
((TypeParameter)newType).bind(oldType);
else
{
if (_otherTypes == null)
_otherTypes = new HashSet(1);
_otherTypes.add(newType);
}
}
return this;
}
public final HashSet otherTypes ()
{
return _otherTypes;
}
public final Expression setOtherTypes (HashSet otherTypes)
{
_otherTypes = otherTypes;
return this;
}
/**
* Adds all the types prescribed for the specified expression to this one.
*/
public final Expression addTypes (Expression expression)
{
addType(expression.typeRef());
HashSet types = expression.otherTypes();
if (types != null)
for (Iterator i=types.iterator();i.hasNext();)
addType((Type)i.next());
return this;
}
/**
* This field may be used to contain this expression's concrete syntax origin.
*/
private Locatable _extent;
public final Locatable extent ()
{
return _extent;
}
public final Expression setExtent (Locatable extent)
{
_extent = extent;
return this;
}
/**
* Returns the start of this expressions's extent as a
* Location.
*/
public final Location getStart ()
{
return _extent == null ? null : _extent.getStart();
}
/**
* Returns the end of this expressions's extent as a
* Location.
*/
public final Location getEnd ()
{
return _extent == null ? null : _extent.getEnd();
}
/**
* Sets the start of this expressions's extent to the specified
* Location and returns this.
*/
public final Locatable setStart (Location location)
{
if (_extent == null) _extent = new Span();
_extent.setStart(location);
return this;
}
/**
* Sets the end of this expressions's extent to the specified
* Location and returns this.
*/
public final Locatable setEnd (Location location)
{
if (_extent == null) _extent = new Span();
_extent.setEnd(location);
return this;
}
/**
* Sets the extent of the specified
* StaticSemanticsErrorException to this expression.
*/
protected final StaticSemanticsErrorException locate (StaticSemanticsErrorException e)
{
return e.setExtent(this);
}
/**
* Returns an explicit string for this expression's extent's location.
*/
public final String locationString ()
{
return Misc.locationString(_extent);
}
/**
* This method analyzes the type boxing information for this expression when it
* occurs as a functional argument of an application. This returns an
* expression equivalent to this one "padded" with un/wrappers as needed to
* reconcile its type boxing information with that of the formal type expected by the
* argument of the function of which it is ac actual argument, and return the
* possibly so-modified expression. It is used by the compile method of an
* application that takes this expression as
* an argument with a functional type. Then, its type information and the type of the
* function's argument position where it appears (passed as argument to this method)
* must be used to determine whether to box or unbox its arguments and result. It is
* defined here as opposed to a concrete subclass of Expression because
* instances of several such classes may have a function type (namely, Scopes, Locals,
* and Globals).
*/
final Expression pad (FunctionType formalType)
{
// This expression has necessarily a function type
FunctionType actualType = (FunctionType)checkedType();
int arity = actualType.arity();
boolean argumentSortsAgree = true;
for (int i=0; i 1 ? "(" : "";
// for (int i=0; i 1 ? ")" : "") + " -> " + outerPadding.checkedType();
// hlt.language.tools.Debug.step(this+" has been padded into: "+abstraction + " : "+s);
// /* end of code for debugging only */
return abstraction;
}
}