Method Validate

cmd/grv/expression_processor.go:543–591

Validate the child expressions and operator are valid

(fieldTypeDescriptor FieldTypeDescriptor)

// Validate the child expressions and operator are valid
func (binaryExpression *BinaryExpression) Validate(fieldTypeDescriptor FieldTypeDescriptor) (errors []error) {
	if !binaryExpression.IsComparison() {
		if logicalExpression, ok := binaryExpression.lhs.(LogicalExpression); !ok {
			errors = append(errors, GenerateExpressionError(binaryExpression, "Operands of a logical operator must resolve to boolean values"))
		} else {
			errors = append(errors, logicalExpression.Validate(fieldTypeDescriptor)...)
		}

		if logicalExpression, ok := binaryExpression.rhs.(LogicalExpression); !ok {
			errors = append(errors, GenerateExpressionError(binaryExpression, "Operands of a logical operator must resolve to boolean values"))
		} else {
			errors = append(errors, logicalExpression.Validate(fieldTypeDescriptor)...)
		}

		return
	}

	if validatableExpression, ok := binaryExpression.lhs.(ValidatableExpression); ok {
		errors = append(errors, validatableExpression.Validate(fieldTypeDescriptor)...)
	}

	if validatableExpression, ok := binaryExpression.rhs.(ValidatableExpression); ok {
		errors = append(errors, validatableExpression.Validate(fieldTypeDescriptor)...)
	}

	lhsType, isLHSValueType := determineFieldType(binaryExpression.lhs, fieldTypeDescriptor)
	rhsType, isRHSValueType := determineFieldType(binaryExpression.rhs, fieldTypeDescriptor)

	if !(isLHSValueType && isRHSValueType) {
		errors = append(errors, GenerateExpressionError(binaryExpression, "Comparison expressions must compare value types"))
	} else if binaryExpression.operator.isOperandTypeRestricted() {
		if !(lhsType == FtInvalid || rhsType == FtInvalid) {
			if !binaryExpression.operator.isValidArgument(bopLeft, lhsType) {
				errors = append(errors, GenerateExpressionError(binaryExpression, "Argument on LHS has invalid type: %v. Allowed types are: %v",
					fieldTypeNames[lhsType], fieldTypeNamesString(binaryExpression.operator.allowedTypes(bopLeft))))
			}

			if !binaryExpression.operator.isValidArgument(bopRight, rhsType) {
				errors = append(errors, GenerateExpressionError(binaryExpression, "Argument on RHS has invalid type: %v. Allowed types are: %v",
					fieldTypeNames[rhsType], fieldTypeNamesString(binaryExpression.operator.allowedTypes(bopRight))))
			}
		}
	} else if lhsType != rhsType && !(lhsType == FtInvalid || rhsType == FtInvalid) {
		errors = append(errors, GenerateExpressionError(binaryExpression, "Attempting to compare different types - LHS Type: %v vs RHS Type: %v",
			fieldTypeNames[lhsType], fieldTypeNames[rhsType]))
	}

	return
}

func determineFieldType(expression Expression, fieldTypeDescriptor FieldTypeDescriptor) (fieldType FieldType, isValueType bool) {
	if typeDescriptor, ok := expression.(TypeDescriptor); ok {