Package nz.org.riskscape.rl.ast

Interface ExpressionProblems

All Superinterfaces:
ProblemFactory
public interface ExpressionProblems extends ProblemFactory

Factory for creating problems involving an expression

  • Method Details

    • get

      static ExpressionProblems get()

      Handy accessor to save on precious keystrokes

    • cannotParse

      static Problem cannotParse(Object expectedThing, String expression)

      General purpose error for invalid expressions that cannot be parsed. Produces an error: "Failed to parse [expectedThing] expression '[expression]' e.g. Failed to parse type expression 'foo.bar'

    • notAValid

      Problem notAValid(Class<?> typeOfThing, String expression)

      Similar to cannotParse(Object, String) but for cases where mentioning 'parsing' is less appropriate. Produces an error: "'[expression]' is not a valid [typeOfThing] expression"

    • constantRequired

      Problem constantRequired(Expression expr)

      Something required a constant expression, but was given a non-constant expression, e.g. "Expected expression 'foo + bar' to be a constant value"

    • mismatch

      Problem mismatch(Expression expr, Class<? extends Expression> requiredType, String example)

      expr is expected to be of requiredType but is not.

    • noSuchOperatorFunction

      Problem noSuchOperatorFunction(String op, List<Type> argTypes)

    • pointlessSelectAllInStruct

      Problem pointlessSelectAllInStruct(StructDeclaration.Member memberDeclaration)

      The user has done something like {foo: bar.*} which is probably a mistake - it should be either {bar.*} or {foo: bar}

    • pointlessSelectAll

      Problem pointlessSelectAll(PropertyAccess expression)

      The user has done something like bar.* outside of a struct, which makes no sense

    • duplicateSelectAll

      Problem duplicateSelectAll(Token duplicate)

      A second * has been put in a struct

    • malformedExpression

      Problem malformedExpression(Source source)

      A parent problem that wraps a more specific problem within the expression

    • malformedExpression

      Problem malformedExpression(Source source, Problem... children)

      Convenience version of malformedExpression(Source)

    • selectAllRequiresAStruct

      Problem selectAllRequiresAStruct(StructDeclaration.Member memberDeclaration, Type resultType)

      Given during realization when a .* is found against a non-struct type, like a list or a number

    • malformedExpressionTip

      Problem malformedExpressionTip()

      Give the user some idea of what to do when an unexpected token exception occurs

    • failedToRealize

      Problem failedToRealize(Expression expression, Type inputType)

      Wraps other problems to give the context for realization failing

    • failedToRealizeParam

      Problem failedToRealizeParam(String token, SourceLocation expressionLocation, Type inputType)

    • lambdaArityError

      Problem lambdaArityError(Expression givenExpression, int found, int expected)
      Returns:
      from function realization when a lambda expression has the wrong number of args

    • propertyOutsideOfAggregationFunction

      Problem propertyOutsideOfAggregationFunction(PropertyAccess expression)

      returned when an aggregate expression has property access expressions that aren't within an aggregate function

    • aggregateFunctionNotSupportedInExpression

      Problem aggregateFunctionNotSupportedInExpression(FunctionCall fc)

    • noSuchStructMember

      Problem noSuchStructMember(Token path, List<String> members)
      Returns:
      when a property expression fails to realize because a member doesn't exist

    • parametersNotAllowed

      Problem parametersNotAllowed(ParameterToken found)

      Generic error that says that an expression is no good in the current context as parameters are not allowed, i.e. there's no opportunity for the user to replace them, so it's never going to work.

      This should be gone by the time #1573 is all done.

    • unresolvedParameter

      default Problem unresolvedParameter(ParameterToken found)

      Found when an expression contains a parameter that didn't get resolved during realization.

    • unresolvedParameter

      Problem unresolvedParameter(ParameterToken found, Problem... child)

    • unresolvedParameterHint

      Problem unresolvedParameterHint()

    • canNotReplaceMember

      Problem canNotReplaceMember(String name, StructDeclaration.Member first, StructDeclaration.Member second)

    • emptyStringNotValid

      Problem emptyStringNotValid()

      Special case parsing error for when the user gives us an empty string

    • evalFailed

      Problem evalFailed(Expression expression)

    • recursiveParameterDetected

      Problem recursiveParameterDetected(List<ParameterToken> chain)