private boolean validTypevarParam(Node expr) { if (!isTypeVar(expr)) { warnInvalid("name", expr); return false; } return true; }
/** * A typeOfVar expression must be of the form typeOfVar('name') */ private boolean validTypeOfVarExpression(Node expr) { // The expression must have two children: // - The typeOfVar keyword // - A string if (!checkParameterCount(expr, Keywords.TYPEOFVAR)) { return false; } if (!getCallArgument(expr, 0).isString()) { warnInvalid("name", expr); warnInvalidInside(Keywords.TYPEOFVAR.name, expr); return false; } return true; }
warnInvalid("boolean predicate", expr); return false;
/** * A typeOfVar expression must be of the form typeOfVar('name') */ private boolean validTypeOfVarExpression(Node expr) { // The expression must have two children: // - The typeOfVar keyword // - A string if (!checkParameterCount(expr, Keywords.TYPEOFVAR)) { return false; } if (!getCallArgument(expr, 0).isString()) { warnInvalid("name", expr); warnInvalidInside(Keywords.TYPEOFVAR.name, expr); return false; } return true; }
warnInvalid("boolean predicate", expr); return false;
private boolean validTypevarParam(Node expr) { if (!isTypeVar(expr)) { warnInvalid("name", expr); return false; } return true; }
private boolean validPropTypeExpression(Node expr) { // The expression must have three children. The propType keyword, a // a string and a type transformation expression if (!checkParameterCount(expr, Keywords.PROPTYPE)) { return false; } if (!getCallArgument(expr, 0).isString()) { warnInvalid("property name", expr); warnInvalidInside(Keywords.PROPTYPE.name, expr); return false; } if (!validTypeTransformationExpression(getCallArgument(expr, 1))) { warnInvalidInside(Keywords.PROPTYPE.name, expr); return false; } return true; }
private boolean isValidStringParam(Node expr) { if (!expr.isName() && !expr.isString()) { warnInvalid("string", expr); return false; } if (expr.getString().isEmpty()) { warnInvalid("string parameter", expr); return false; } return true; }
private boolean validPrintTypeExpression(Node expr) { // The expression must have three children. The printType keyword, a // message and a type transformation expression if (!checkParameterCount(expr, Keywords.PRINTTYPE)) { return false; } if (!getCallArgument(expr, 0).isString()) { warnInvalid("message", expr); warnInvalidInside(Keywords.PRINTTYPE.name, expr); return false; } if (!validTypeTransformationExpression(getCallArgument(expr, 1))) { warnInvalidInside(Keywords.PRINTTYPE.name, expr); return false; } return true; }
private boolean isValidStringParam(Node expr) { if (!expr.isName() && !expr.isString()) { warnInvalid("string", expr); return false; } if (expr.getString().isEmpty()) { warnInvalid("string parameter", expr); return false; } return true; }
private boolean validPropTypeExpression(Node expr) { // The expression must have three children. The propType keyword, a // a string and a type transformation expression if (!checkParameterCount(expr, Keywords.PROPTYPE)) { return false; } if (!getCallArgument(expr, 0).isString()) { warnInvalid("property name", expr); warnInvalidInside(Keywords.PROPTYPE.name, expr); return false; } if (!validTypeTransformationExpression(getCallArgument(expr, 1))) { warnInvalidInside(Keywords.PROPTYPE.name, expr); return false; } return true; }
/** * A record must be a valid type transformation expression or a node of the form: * {prop:TTLExp, prop:TTLExp, ...} * Notice that the values are mandatory and they must be valid type * transformation expressions */ private boolean validRecordParam(Node expr) { if (expr.isObjectLit()) { // Each value of a property must be a valid expression for (Node prop : expr.children()) { if (prop.isShorthandProperty()) { warnInvalid("property, missing type", prop); return false; } else if (!validTypeTransformationExpression(prop.getFirstChild())) { return false; } } } else if (!validTypeTransformationExpression(expr)) { return false; } return true; }
/** * A template type of expression must be of the form * templateTypeOf(TTLExp, index) */ private boolean validTemplateTypeOfExpression(Node expr) { // The expression must have three children. The templateTypeOf keyword, a // templatized type and an index if (!checkParameterCount(expr, Keywords.TEMPLATETYPEOF)) { return false; } // The parameter must be a valid type expression if (!validTypeTransformationExpression(getCallArgument(expr, 0))) { warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr); return false; } if (!getCallArgument(expr, 1).isNumber()) { warnInvalid("index", expr); warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr); return false; } double index = getCallArgument(expr, 1).getDouble(); if (index < 0 || index % 1 != 0) { warnInvalid("index", expr); warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr); return false; } return true; }
/** * A record must be a valid type transformation expression or a node of the form: * {prop:TTLExp, prop:TTLExp, ...} * Notice that the values are mandatory and they must be valid type * transformation expressions */ private boolean validRecordParam(Node expr) { if (expr.isObjectLit()) { // Each value of a property must be a valid expression for (Node prop : expr.children()) { if (!prop.hasChildren()) { warnInvalid("property, missing type", prop); return false; } else if (!validTypeTransformationExpression(prop.getFirstChild())) { return false; } } } else if (!validTypeTransformationExpression(expr)) { return false; } return true; }
private boolean validPrintTypeExpression(Node expr) { // The expression must have three children. The printType keyword, a // message and a type transformation expression if (!checkParameterCount(expr, Keywords.PRINTTYPE)) { return false; } if (!getCallArgument(expr, 0).isString()) { warnInvalid("message", expr); warnInvalidInside(Keywords.PRINTTYPE.name, expr); return false; } if (!validTypeTransformationExpression(getCallArgument(expr, 1))) { warnInvalidInside(Keywords.PRINTTYPE.name, expr); return false; } return true; }
/** * A template type of expression must be of the form * templateTypeOf(TTLExp, index) */ private boolean validTemplateTypeOfExpression(Node expr) { // The expression must have three children. The templateTypeOf keyword, a // templatized type and an index if (!checkParameterCount(expr, Keywords.TEMPLATETYPEOF)) { return false; } // The parameter must be a valid type expression if (!validTypeTransformationExpression(getCallArgument(expr, 0))) { warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr); return false; } if (!getCallArgument(expr, 1).isNumber()) { warnInvalid("index", expr); warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr); return false; } double index = getCallArgument(expr, 1).getDouble(); if (index < 0 || index % 1 != 0) { warnInvalid("index", expr); warnInvalidInside(Keywords.TEMPLATETYPEOF.name, expr); return false; } return true; }
/** * A template type expression must be of the form type(typename, TTLExp,...) * or type(typevar, TTLExp...) */ private boolean validTemplateTypeExpression(Node expr) { // The expression must have at least three children the type keyword, // a type name (or type variable) and a type expression if (!checkParameterCount(expr, Keywords.TYPE)) { return false; } int paramCount = getCallParamCount(expr); // The first parameter must be a type variable or a type name Node firstParam = getCallArgument(expr, 0); if (!isTypeVar(firstParam) && !isTypeName(firstParam)) { warnInvalid("type name or type variable", expr); warnInvalidInside("template type operation", expr); return false; } // The rest of the parameters must be valid type expressions for (int i = 1; i < paramCount; i++) { if (!validTypeTransformationExpression(getCallArgument(expr, i))) { warnInvalidInside("template type operation", expr); return false; } } return true; }
/** * A template type expression must be of the form type(typename, TTLExp,...) * or type(typevar, TTLExp...) */ private boolean validTemplateTypeExpression(Node expr) { // The expression must have at least three children the type keyword, // a type name (or type variable) and a type expression if (!checkParameterCount(expr, Keywords.TYPE)) { return false; } int paramCount = getCallParamCount(expr); // The first parameter must be a type variable or a type name Node firstParam = getCallArgument(expr, 0); if (!isTypeVar(firstParam) && !isTypeName(firstParam)) { warnInvalid("type name or type variable", expr); warnInvalidInside("template type operation", expr); return false; } // The rest of the parameters must be valid type expressions for (int i = 1; i < paramCount; i++) { if (!validTypeTransformationExpression(getCallArgument(expr, i))) { warnInvalidInside("template type operation", expr); return false; } } return true; }
warnInvalid("map function", getCallArgument(expr, 1)); warnInvalidInside(Keywords.MAPUNION.name, getCallArgument(expr, 1)); return false;
warnInvalid("map function", getCallArgument(expr, 1)); warnInvalidInside(Keywords.MAPRECORD.name, getCallArgument(expr, 1)); return false;