public TCExplicitFunctionDefinition(
TCAccessSpecifier accessSpecifier,
TCNameToken name,
TCNameList typeParams,
TCFunctionType type,
TCPatternListList parameters,
TCExpression body,
TCExpression precondition,
TCExpression postcondition,
boolean typeInvariant,
TCNameToken measure) {
super(Pass.DEFS, name.getLocation(), name, NameScope.GLOBAL);
this.accessSpecifier = accessSpecifier;
this.typeParams = typeParams;
this.type = type;
this.paramPatternList = parameters;
this.precondition = precondition;
this.postcondition = postcondition;
this.body = body;
this.isTypeInvariant = typeInvariant;
this.measure = measure;
this.isCurried = parameters.size() > 1;
type.definitions = new TCDefinitionList(this);
type.instantiated = typeParams == null ? null : false;
}
@Override
public void typeResolve(Environment base) {
if (typeParams != null) {
FlatCheckedEnvironment params =
new FlatCheckedEnvironment(getTypeParamDefinitions(), base, NameScope.NAMES);
type = type.typeResolve(params, null);
} else {
type = type.typeResolve(base, null);
}
if (base.isVDMPP()) {
name.setTypeQualifier(type.parameters);
}
if (body instanceof TCSubclassResponsibilityExpression
|| body instanceof TCNotYetSpecifiedExpression) {
isUndefined = true;
}
if (precondition != null) {
predef.typeResolve(base);
}
if (postcondition != null) {
postdef.typeResolve(base);
}
for (TCPatternList pp : paramPatternList) {
pp.typeResolve(base);
}
}
public TCFunctionType getType(TCTypeList actualTypes) {
Iterator<TCType> ti = actualTypes.iterator();
TCFunctionType ftype = type;
if (typeParams != null) {
for (TCNameToken pname : typeParams) {
TCType ptype = ti.next();
ftype = (TCFunctionType) ftype.polymorph(pname, ptype);
}
ftype.instantiated = true;
}
return ftype;
}
private TCExplicitFunctionDefinition getPostDefinition() {
TCPatternList last = new TCPatternList();
int psize = paramPatternList.size();
for (TCPattern p : paramPatternList.get(psize - 1)) {
last.add(p);
}
last.add(new TCIdentifierPattern(name.getResultName(location)));
TCPatternListList parameters = new TCPatternListList();
if (psize > 1) {
parameters.addAll(paramPatternList.subList(0, psize - 1));
}
parameters.add(last);
TCExplicitFunctionDefinition def =
new TCExplicitFunctionDefinition(
accessSpecifier,
name.getPostName(postcondition.location),
typeParams,
type.getCurriedPostType(isCurried),
parameters,
postcondition,
null,
null,
false,
null);
def.classDefinition = classDefinition;
return def;
}
private TCExplicitFunctionDefinition getPreDefinition() {
TCExplicitFunctionDefinition def =
new TCExplicitFunctionDefinition(
accessSpecifier,
name.getPreName(precondition.location),
typeParams,
type.getCurriedPreType(isCurried),
paramPatternList,
precondition,
null,
null,
false,
null);
def.classDefinition = classDefinition;
return def;
}
@Override
public void typeCheck(Environment base, NameScope scope) {
TCDefinitionList defs = new TCDefinitionList();
if (typeParams != null) {
defs.addAll(getTypeParamDefinitions());
}
TypeComparator.checkComposeTypes(type, base, false);
expectedResult = checkParams(paramPatternList.listIterator(), type);
paramDefinitionList = getParamDefinitions();
for (TCDefinitionList pdef : paramDefinitionList) {
defs.addAll(pdef); // All definitions of all parameter lists
}
FlatEnvironment local = new FlatCheckedEnvironment(defs, base, scope);
FlatCheckedEnvironment checked = (FlatCheckedEnvironment) local;
checked.setStatic(accessSpecifier);
checked.setEnclosingDefinition(this);
checked.setFunctional(true);
defs.typeCheck(local, scope);
if (base.isVDMPP() && !accessSpecifier.isStatic) {
local.add(getSelfDefinition());
}
if (predef != null) {
TCBooleanType expected = new TCBooleanType(location);
TCType b = predef.body.typeCheck(local, null, NameScope.NAMES, expected);
if (!b.isType(TCBooleanType.class, location)) {
report(3018, "Precondition returns unexpected type");
detail2("Actual", b, "Expected", expected);
}
TCDefinitionList qualified = predef.body.getQualifiedDefs(local);
if (!qualified.isEmpty()) {
local = new FlatEnvironment(qualified, local); // NB Not checked!
}
}
if (postdef != null) {
TCPattern rp = new TCIdentifierPattern(name.getResultName(location));
TCDefinitionList rdefs = rp.getDefinitions(expectedResult, NameScope.NAMES);
FlatCheckedEnvironment post = new FlatCheckedEnvironment(rdefs, local, NameScope.NAMES);
TCBooleanType expected = new TCBooleanType(location);
TCType b = postdef.body.typeCheck(post, null, NameScope.NAMES, expected);
if (!b.isType(TCBooleanType.class, location)) {
report(3018, "Postcondition returns unexpected type");
detail2("Actual", b, "Expected", expected);
}
}
// This check returns the type of the function body in the case where
// all of the curried parameter sets are provided.
actualResult = body.typeCheck(local, null, scope, expectedResult);
if (!TypeComparator.compatible(expectedResult, actualResult)) {
report(3018, "Function returns unexpected type");
detail2("Actual", actualResult, "Expected", expectedResult);
}
if (type.narrowerThan(accessSpecifier)) {
report(3019, "Function parameter visibility less than function definition");
}
if (base.isVDMPP()
&& accessSpecifier.access == Token.PRIVATE
&& body instanceof TCSubclassResponsibilityExpression) {
report(3329, "Abstract function/operation must be public or protected");
}
if (measure == null && recursive) {
warning(5012, "Recursive function has no measure");
} else if (measure != null) {
if (base.isVDMPP()) measure.setTypeQualifier(getMeasureParams());
measuredef = base.findName(measure, scope);
if (measuredef == null) {
measure.report(3270, "Measure " + measure + " is not in scope");
} else if (!(measuredef instanceof TCExplicitFunctionDefinition)) {
measure.report(3271, "Measure " + measure + " is not an explicit function");
} else if (measuredef == this) {
measure.report(3304, "Recursive function cannot be its own measure");
} else {
TCExplicitFunctionDefinition efd = (TCExplicitFunctionDefinition) measuredef;
if (this.typeParams == null && efd.typeParams != null) {
measure.report(3309, "Measure must not be polymorphic");
} else if (this.typeParams != null && efd.typeParams == null) {
measure.report(3310, "Measure must also be polymorphic");
} else if (this.typeParams != null
&& efd.typeParams != null
&& !this.typeParams.equals(efd.typeParams)) {
measure.report(3318, "Measure's type parameters must match function's");
detail2("Actual", efd.typeParams, "Expected", typeParams);
}
TCFunctionType mtype = (TCFunctionType) measuredef.getType();
if (typeParams != null) // Polymorphic, so compare "shape" of param signature
{
if (!mtype.parameters.toString().equals(getMeasureParams().toString())) {
measure.report(3303, "Measure parameters different to function");
detail2(measure.getName(), mtype.parameters, "Expected", getMeasureParams());
}
} else if (!TypeComparator.compatible(mtype.parameters, getMeasureParams())) {
measure.report(3303, "Measure parameters different to function");
detail2(measure.getName(), mtype.parameters, "Expected", getMeasureParams());
}
if (!(mtype.result instanceof TCNaturalType)) {
if (mtype.result.isProduct(location)) {
TCProductType pt = mtype.result.getProduct();
for (TCType t : pt.types) {
if (!(t instanceof TCNaturalType)) {
measure.report(3272, "Measure range is not a nat, or a nat tuple");
measure.detail("Actual", mtype.result);
break;
}
}
measureLexical = pt.types.size();
} else {
measure.report(3272, "Measure range is not a nat, or a nat tuple");
measure.detail("Actual", mtype.result);
}
}
}
}
if (!(body instanceof TCNotYetSpecifiedExpression)
&& !(body instanceof TCSubclassResponsibilityExpression)) {
local.unusedCheck();
}
}