Package net.sf.saxon.expr.compat

## Class TypeChecker10

- java.lang.Object
- - net.sf.saxon.expr.parser.TypeChecker
  - - net.sf.saxon.expr.compat.TypeChecker10

-     public class TypeChecker10
      extends TypeChecker

  This class provides type checking capability with XPath 1.0 backwards compatibility enabled.

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `TypeChecker10()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Expression` | `makeArithmeticExpression​(Expression lhs, int operator, Expression rhs)` |
    `Expression` | `makeGeneralComparison​(Expression lhs, int operator, Expression rhs)` |
    `Expression` | `processValueOf​(Expression select, Configuration config)` |
    `Expression` | `staticTypeCheck​(Expression supplied, SequenceType req, RoleDiagnostic role, ExpressionVisitor visitor)` | Check an expression against a required type, modifying it if necessary.

    - ### Methods inherited from class net.sf.saxon.expr.parser.TypeChecker

      `ebvError, strictTypeCheck, testConformance`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### TypeChecker10

          public TypeChecker10()

  - ### Method Detail

    - #### staticTypeCheck

          public Expression staticTypeCheck​(Expression supplied,
                                            SequenceType req,
                                            RoleDiagnostic role,
                                            ExpressionVisitor visitor)
                                     throws XPathException

      Description copied from class: `TypeChecker`
      Check an expression against a required type, modifying it if necessary.

      This method takes the supplied expression and checks to see whether it is known statically to conform to the specified type. There are three possible outcomes. If the static type of the expression is a subtype of the required type, the method returns the expression unchanged. If the static type of the expression is incompatible with the required type (for example, if the supplied type is integer and the required type is string) the method throws an exception (this results in a compile-time type error being reported). If the static type is a supertype of the required type, then a new expression is constructed that evaluates the original expression and checks the dynamic type of the result; this new expression is returned as the result of the method.

      The rules applied are those for function calling in XPath, that is, the rules that the argument of a function call must obey in relation to the signature of the function. Some contexts require slightly different rules (for example, operands of polymorphic operators such as "+"). In such cases this method cannot be used.

      Note that this method does not do recursive type-checking of the sub-expressions.

      Overrides:
        `staticTypeCheck` in class `TypeChecker`
      Parameters:
        `supplied` - The expression to be type-checked
        `req` - The required type for the context in which the expression is used
        `role` - Information about the role of the subexpression within the containing expression, used to provide useful error messages
        `visitor` - An expression visitor
      Returns:
        The original expression if it is type-safe, or the expression wrapped in a run-time type checking expression if not.
      Throws:
        `XPathException` - if the supplied type is statically inconsistent with the required type (that is, if they have no common subtype)

    - #### makeArithmeticExpression

          public Expression makeArithmeticExpression​(Expression lhs,
                                                     int operator,
                                                     Expression rhs)

      Overrides:
        `makeArithmeticExpression` in class `TypeChecker`

    - #### makeGeneralComparison

          public Expression makeGeneralComparison​(Expression lhs,
                                                  int operator,
                                                  Expression rhs)

      Overrides:
        `makeGeneralComparison` in class `TypeChecker`

    - #### processValueOf

          public Expression processValueOf​(Expression select,
                                           Configuration config)

      Overrides:
        `processValueOf` in class `TypeChecker`