remove ErrorValue from eval library

10 files changed, 35 insertions, 79 deletions

diff --git a/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp b/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
index 714eb870b3e..9112a8b1712 100644
--- a/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
+++ b/eval/src/tests/eval/interpreted_function/interpreted_function_test.cpp
@@ -100,16 +100,10 @@ TEST_FF("require that compiled evaluation passes all conformance tests", MyEvalT
 
 //-----------------------------------------------------------------------------
 
-TEST("require that invalid function evaluates to a error") {
+TEST("require that invalid function is tagged with error") {
     std::vector<vespalib::string> params({"x", "y", "z", "w"});
     Function function = Function::parse(params, "x & y");
     EXPECT_TRUE(function.has_error());
-    InterpretedFunction ifun(SimpleTensorEngine::ref(), function, NodeTypes());
-    InterpretedFunction::Context ctx(ifun);
-    SimpleParams my_params({1,2,3,4});
-    const Value &result = ifun.eval(ctx, my_params);
-    EXPECT_TRUE(result.is_error());
-    EXPECT_EQUAL(error_value, result.as_double());
 }
 
 //-----------------------------------------------------------------------------
diff --git a/eval/src/tests/eval/tensor_function/tensor_function_test.cpp b/eval/src/tests/eval/tensor_function/tensor_function_test.cpp
index 741b756e46f..7bca3d14c28 100644
--- a/eval/src/tests/eval/tensor_function/tensor_function_test.cpp
+++ b/eval/src/tests/eval/tensor_function/tensor_function_test.cpp
@@ -15,13 +15,12 @@ using namespace vespalib::eval::tensor_function;
 struct EvalCtx {
     const TensorEngine &engine;
     Stash stash;
-    ErrorValue error;
     std::vector<Value::UP> tensors;
     std::vector<Value::CREF> params;
     InterpretedFunction::UP ifun;
     std::unique_ptr<InterpretedFunction::Context> ictx;
     EvalCtx(const TensorEngine &engine_in)
-        : engine(engine_in), stash(), error(), tensors(), params(), ifun(), ictx() {}
+        : engine(engine_in), stash(), tensors(), params(), ifun(), ictx() {}
     ~EvalCtx() {}
     size_t add_tensor(Value::UP tensor) {
         size_t id = params.size();
diff --git a/eval/src/vespa/eval/eval/basic_nodes.cpp b/eval/src/vespa/eval/eval/basic_nodes.cpp
index 85e00e76803..6138f9ac073 100644
--- a/eval/src/vespa/eval/eval/basic_nodes.cpp
+++ b/eval/src/vespa/eval/eval/basic_nodes.cpp
@@ -21,8 +21,8 @@ struct Frame {
 };
 
 struct NoParams : LazyParams {
-    const Value &resolve(size_t, Stash &stash) const override {
-        return stash.create<ErrorValue>();
+    const Value &resolve(size_t, Stash &) const override {
+        abort();
     }
 };
 
diff --git a/eval/src/vespa/eval/eval/interpreted_function.cpp b/eval/src/vespa/eval/eval/interpreted_function.cpp
index e362faadf46..208b2db4c3a 100644
--- a/eval/src/vespa/eval/eval/interpreted_function.cpp
+++ b/eval/src/vespa/eval/eval/interpreted_function.cpp
@@ -91,9 +91,7 @@ InterpretedFunction::eval(Context &ctx, const LazyParams &params) const
     while (state.program_offset < _program.size()) {
         _program[state.program_offset++].perform(state);
     }
-    if (state.stack.size() != 1) {
-        state.stack.push_back(state.stash.create<ErrorValue>());
-    }
+    assert(state.stack.size() == 1);
     return state.stack.back();
 }
 
diff --git a/eval/src/vespa/eval/eval/make_tensor_function.cpp b/eval/src/vespa/eval/eval/make_tensor_function.cpp
index d84d9f53749..ebf065f32a1 100644
--- a/eval/src/vespa/eval/eval/make_tensor_function.cpp
+++ b/eval/src/vespa/eval/eval/make_tensor_function.cpp
@@ -142,8 +142,8 @@ struct TensorFunctionBuilder : public NodeVisitor, public NodeTraverser {
     void visit(const If &node) override {
         make_if(node);
     }
-    void visit(const Error &node) override {
-        make_const(node, ErrorValue::instance);
+    void visit(const Error &) override {
+        abort();
     }
     void visit(const TensorMap &node) override {
         const auto &token = stash.create<CompileCache::Token::UP>(CompileCache::compile(node.lambda(), PassParams::SEPARATE));
diff --git a/eval/src/vespa/eval/eval/simple_tensor_engine.cpp b/eval/src/vespa/eval/eval/simple_tensor_engine.cpp
index c8c9a82d267..25fc98fc00a 100644
--- a/eval/src/vespa/eval/eval/simple_tensor_engine.cpp
+++ b/eval/src/vespa/eval/eval/simple_tensor_engine.cpp
@@ -40,22 +40,14 @@ const Value &to_value(std::unique_ptr<SimpleTensor> tensor, Stash &stash) {
     if (tensor->type().is_tensor()) {
         return *stash.create<Value::UP>(std::move(tensor));
     }
-    if (tensor->type().is_double()) {
-        return stash.create<DoubleValue>(tensor->as_double());
-    }
-    assert(tensor->type().is_error());
-    return ErrorValue::instance;
+    return stash.create<DoubleValue>(tensor->as_double());
 }
 
 Value::UP to_value(std::unique_ptr<SimpleTensor> tensor) {
     if (tensor->type().is_tensor()) {
         return tensor;
     }
-    if (tensor->type().is_double()) {
-        return std::make_unique<DoubleValue>(tensor->as_double());
-    }
-    assert(tensor->type().is_error());
-    return std::make_unique<ErrorValue>();
+    return std::make_unique<DoubleValue>(tensor->as_double());
 }
 
 } // namespace vespalib::eval::<unnamed>
diff --git a/eval/src/vespa/eval/eval/test/tensor_conformance.cpp b/eval/src/vespa/eval/eval/test/tensor_conformance.cpp
index 8cbc7507592..7e512bb5bf1 100644
--- a/eval/src/vespa/eval/eval/test/tensor_conformance.cpp
+++ b/eval/src/vespa/eval/eval/test/tensor_conformance.cpp
@@ -298,7 +298,6 @@ struct TestContext {
     }
 
     void test_tensor_create_type() {
-        TEST_DO(verify_create_type("error"));
         TEST_DO(verify_create_type("double"));
         TEST_DO(verify_create_type("tensor(x{})"));
         TEST_DO(verify_create_type("tensor(x{},y{})"));
diff --git a/eval/src/vespa/eval/eval/value.cpp b/eval/src/vespa/eval/eval/value.cpp
index 4bfd758f9cd..3629a5ad698 100644
--- a/eval/src/vespa/eval/eval/value.cpp
+++ b/eval/src/vespa/eval/eval/value.cpp
@@ -6,9 +6,6 @@
 namespace vespalib {
 namespace eval {
 
-ValueType ErrorValue::_type = ValueType::error_type();
-const ErrorValue ErrorValue::instance;
-
 ValueType DoubleValue::_type = ValueType::double_type();
 
 } // namespace vespalib::eval
diff --git a/eval/src/vespa/eval/eval/value.h b/eval/src/vespa/eval/eval/value.h
index f14034968be..15df44efbac 100644
--- a/eval/src/vespa/eval/eval/value.h
+++ b/eval/src/vespa/eval/eval/value.h
@@ -20,7 +20,6 @@ constexpr double error_value = 31212.0;
 struct Value {
     typedef std::unique_ptr<Value> UP;
     typedef std::reference_wrapper<const Value> CREF;
-    virtual bool is_error() const { return false; }
     virtual bool is_double() const { return false; }
     virtual bool is_tensor() const { return false; }
     virtual double as_double() const { return 0.0; }
@@ -30,17 +29,6 @@ struct Value {
     virtual ~Value() {}
 };
 
-class ErrorValue : public Value
-{
-private:
-    static ValueType _type;
-public:
-    static const ErrorValue instance;
-    bool is_error() const override { return true; }
-    double as_double() const override { return error_value; }
-    const ValueType &type() const override { return _type; }
-};
-
 class DoubleValue : public Value
 {
 private:
diff --git a/eval/src/vespa/eval/tensor/default_tensor_engine.cpp b/eval/src/vespa/eval/tensor/default_tensor_engine.cpp
index 2206cde49a9..a265ae5ae85 100644
--- a/eval/src/vespa/eval/tensor/default_tensor_engine.cpp
+++ b/eval/src/vespa/eval/tensor/default_tensor_engine.cpp
@@ -33,7 +33,6 @@ namespace vespalib::tensor {
 using eval::Aggr;
 using eval::Aggregator;
 using eval::DoubleValue;
-using eval::ErrorValue;
 using eval::TensorFunction;
 using eval::TensorSpec;
 using eval::Value;
@@ -83,7 +82,7 @@ const Value &to_default(const Value &value, Stash &stash) {
 
 const Value &to_value(std::unique_ptr<Tensor> tensor, Stash &stash) {
     if (!tensor) {
-        return ErrorValue::instance;
+        return stash.create<DoubleValue>(eval::error_value);
     }
     if (tensor->type().is_tensor()) {
         return *stash.create<Value::UP>(std::move(tensor));
@@ -93,7 +92,7 @@ const Value &to_value(std::unique_ptr<Tensor> tensor, Stash &stash) {
 
 Value::UP to_value(std::unique_ptr<Tensor> tensor) {
     if (!tensor) {
-        return std::make_unique<ErrorValue>();
+        return std::make_unique<DoubleValue>(eval::error_value);
     }
     if (tensor->type().is_tensor()) {
         return tensor;
@@ -171,7 +170,7 @@ DefaultTensorEngine::from_spec(const TensorSpec &spec) const
 {
     ValueType type = ValueType::from_spec(spec.type());
     if (type.is_error()) {
-        return std::make_unique<ErrorValue>();
+        bad_spec(spec);
     } else if (type.is_double()) {
         double value = spec.cells().empty() ? 0.0 : spec.cells().begin()->second.value;
         return std::make_unique<DoubleValue>(value);
@@ -273,9 +272,7 @@ DefaultTensorEngine::optimize(const TensorFunction &expr, Stash &stash) const
 const Value &
 DefaultTensorEngine::map(const Value &a, map_fun_t function, Stash &stash) const
 {
-    if (a.is_double()) {
-        return stash.create<DoubleValue>(function(a.as_double()));
-    } else if (auto tensor = a.as_tensor()) {
+    if (auto tensor = a.as_tensor()) {
         assert(&tensor->engine() == this);
         const tensor::Tensor &my_a = static_cast<const tensor::Tensor &>(*tensor);
         if (!tensor::Tensor::supported({my_a.type()})) {
@@ -284,63 +281,49 @@ DefaultTensorEngine::map(const Value &a, map_fun_t function, Stash &stash) const
         CellFunctionFunAdapter cell_function(function);
         return to_value(my_a.apply(cell_function), stash);
     } else {
-        return ErrorValue::instance;
+        return stash.create<DoubleValue>(function(a.as_double()));
     }
 }
 
 const Value &
 DefaultTensorEngine::join(const Value &a, const Value &b, join_fun_t function, Stash &stash) const
 {
-    if (a.is_double()) {
-        if (b.is_double()) {
-            return stash.create<DoubleValue>(function(a.as_double(), b.as_double()));
-        } else if (auto tensor_b = b.as_tensor()) {
+    if (auto tensor_a = a.as_tensor()) {
+        assert(&tensor_a->engine() == this);
+        const tensor::Tensor &my_a = static_cast<const tensor::Tensor &>(*tensor_a);
+        if (auto tensor_b = b.as_tensor()) {
             assert(&tensor_b->engine() == this);
             const tensor::Tensor &my_b = static_cast<const tensor::Tensor &>(*tensor_b);
-            if (!tensor::Tensor::supported({my_b.type()})) {
+            if (!tensor::Tensor::supported({my_a.type(), my_b.type()})) {
                 return fallback_join(a, b, function, stash);
             }
-            CellFunctionBindLeftAdapter cell_function(function, a.as_double());
-            return to_value(my_b.apply(cell_function), stash);
+            return to_value(my_a.join(function, my_b), stash);
         } else {
-            return ErrorValue::instance;
-        }
-    } else if (auto tensor_a = a.as_tensor()) {
-        assert(&tensor_a->engine() == this);
-        const tensor::Tensor &my_a = static_cast<const tensor::Tensor &>(*tensor_a);
-        if (b.is_double()) {
             if (!tensor::Tensor::supported({my_a.type()})) {
                 return fallback_join(a, b, function, stash);
             }
             CellFunctionBindRightAdapter cell_function(function, b.as_double());
             return to_value(my_a.apply(cell_function), stash);
-        } else if (auto tensor_b = b.as_tensor()) {
+        }
+    } else {
+        if (auto tensor_b = b.as_tensor()) {
             assert(&tensor_b->engine() == this);
             const tensor::Tensor &my_b = static_cast<const tensor::Tensor &>(*tensor_b);
-            if (!tensor::Tensor::supported({my_a.type(), my_b.type()})) {
+            if (!tensor::Tensor::supported({my_b.type()})) {
                 return fallback_join(a, b, function, stash);
             }
-            return to_value(my_a.join(function, my_b), stash);
+            CellFunctionBindLeftAdapter cell_function(function, a.as_double());
+            return to_value(my_b.apply(cell_function), stash);
         } else {
-            return ErrorValue::instance;
+            return stash.create<DoubleValue>(function(a.as_double(), b.as_double()));
         }
-    } else {
-        return ErrorValue::instance;
     }
 }
 
 const Value &
 DefaultTensorEngine::reduce(const Value &a, Aggr aggr, const std::vector<vespalib::string> &dimensions, Stash &stash) const
 {
-    if (a.is_double()) {
-        if (dimensions.empty()) {
-            Aggregator &aggregator = Aggregator::create(aggr, stash);
-            aggregator.first(a.as_double());
-            return stash.create<DoubleValue>(aggregator.result());
-        } else {
-            return ErrorValue::instance;
-        }
-    } else if (auto tensor = a.as_tensor()) {
+    if (auto tensor = a.as_tensor()) {
         assert(&tensor->engine() == this);
         const tensor::Tensor &my_a = static_cast<const tensor::Tensor &>(*tensor);
         if (!tensor::Tensor::supported({my_a.type()})) {
@@ -360,7 +343,13 @@ DefaultTensorEngine::reduce(const Value &a, Aggr aggr, const std::vector<vespali
             return fallback_reduce(a, aggr, dimensions, stash);
         }
     } else {
-        return ErrorValue::instance;
+        if (dimensions.empty()) {
+            Aggregator &aggregator = Aggregator::create(aggr, stash);
+            aggregator.first(a.as_double());
+            return stash.create<DoubleValue>(aggregator.result());
+        } else {
+            return stash.create<DoubleValue>(eval::error_value);
+        }
     }
 }