Add SMTLogicException

libsmtutil/CHCSmtLib2Interface.cpp

@@ -53,8 +53,8 @@ void CHCSmtLib2Interface::reset()
 
 void CHCSmtLib2Interface::registerRelation(Expression const& _expr)
 {
-	solAssert(_expr.sort, "");
-	solAssert(_expr.sort->kind == Kind::Function, "");
+	smtAssert(_expr.sort, "");
+	smtAssert(_expr.sort->kind == Kind::Function, "");
 	if (!m_variables.count(_expr.name))
 	{
 		auto fSort = dynamic_pointer_cast<FunctionSort>(_expr.sort);
@@ -112,7 +112,7 @@ pair<CheckResult, vector<string>> CHCSmtLib2Interface::query(Expression const& _
 
 void CHCSmtLib2Interface::declareVariable(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
+	smtAssert(_sort, "");
 	if (_sort->kind == Kind::Function)
 		declareFunction(_name, _sort);
 	else if (!m_variables.count(_name))
@@ -124,13 +124,13 @@ void CHCSmtLib2Interface::declareVariable(string const& _name, SortPointer const
 
 void CHCSmtLib2Interface::declareFunction(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
-	solAssert(_sort->kind == Kind::Function, "");
+	smtAssert(_sort, "");
+	smtAssert(_sort->kind == Kind::Function, "");
 	// TODO Use domain and codomain as key as well
 	if (!m_variables.count(_name))
 	{
 		auto fSort = dynamic_pointer_cast<FunctionSort>(_sort);
-		solAssert(fSort->codomain, "");
+		smtAssert(fSort->codomain, "");
 		string domain = m_smtlib2->toSmtLibSort(fSort->domain);
 		string codomain = m_smtlib2->toSmtLibSort(*fSort->codomain);
 		m_variables.insert(_name);

libsmtutil/CMakeLists.txt

@@ -1,6 +1,7 @@
 set(sources
 	CHCSmtLib2Interface.cpp
 	CHCSmtLib2Interface.h
+	Exceptions.h
 	SMTLib2Interface.cpp
 	SMTLib2Interface.h
 	SMTPortfolio.cpp

libsmtutil/CVC4Interface.cpp

@@ -17,7 +17,6 @@
 
 #include <libsmtutil/CVC4Interface.h>
 
-#include <liblangutil/Exceptions.h>
 #include <libsolutil/CommonIO.h>
 
 using namespace std;
@@ -51,7 +50,7 @@ void CVC4Interface::pop()
 
 void CVC4Interface::declareVariable(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
+	smtAssert(_sort, "");
 	m_variables[_name] = m_context.mkVar(_name.c_str(), cvc4Sort(*_sort));
 }
 
@@ -63,19 +62,19 @@ void CVC4Interface::addAssertion(Expression const& _expr)
 	}
 	catch (CVC4::TypeCheckingException const& _e)
 	{
-		solAssert(false, _e.what());
+		smtAssert(false, _e.what());
 	}
 	catch (CVC4::LogicException const& _e)
 	{
-		solAssert(false, _e.what());
+		smtAssert(false, _e.what());
 	}
 	catch (CVC4::UnsafeInterruptException const& _e)
 	{
-		solAssert(false, _e.what());
+		smtAssert(false, _e.what());
 	}
 	catch (CVC4::Exception const& _e)
 	{
-		solAssert(false, _e.what());
+		smtAssert(false, _e.what());
 	}
 }
 
@@ -97,7 +96,7 @@ pair<CheckResult, vector<string>> CVC4Interface::check(vector<Expression> const&
 			result = CheckResult::UNKNOWN;
 			break;
 		default:
-			solAssert(false, "");
+			smtAssert(false, "");
 		}
 
 		if (result == CheckResult::SATISFIABLE && !_expressionsToEvaluate.empty())
@@ -147,15 +146,15 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 				}
 				catch (CVC4::TypeCheckingException const& _e)
 				{
-					solAssert(false, _e.what());
+					smtAssert(false, _e.what());
 				}
 				catch (CVC4::Exception const& _e)
 				{
-					solAssert(false, _e.what());
+					smtAssert(false, _e.what());
 				}
 		}
 
-		solAssert(_expr.hasCorrectArity(), "");
+		smtAssert(_expr.hasCorrectArity(), "");
 		if (n == "ite")
 			return arguments[0].iteExpr(arguments[1], arguments[2]);
 		else if (n == "not")
@@ -193,13 +192,13 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 		else if (n == "const_array")
 		{
 			shared_ptr<SortSort> sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments[0].sort);
-			solAssert(sortSort, "");
+			smtAssert(sortSort, "");
 			return m_context.mkConst(CVC4::ArrayStoreAll(cvc4Sort(*sortSort->inner), arguments[1]));
 		}
 		else if (n == "tuple_get")
 		{
 			shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.arguments[0].sort);
-			solAssert(tupleSort, "");
+			smtAssert(tupleSort, "");
 			CVC4::DatatypeType tt = m_context.mkTupleType(cvc4Sort(tupleSort->components));
 			CVC4::Datatype const& dt = tt.getDatatype();
 			size_t index = std::stoi(_expr.arguments[1].name);
@@ -209,25 +208,25 @@ CVC4::Expr CVC4Interface::toCVC4Expr(Expression const& _expr)
 		else if (n == "tuple_constructor")
 		{
 			shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_expr.sort);
-			solAssert(tupleSort, "");
+			smtAssert(tupleSort, "");
 			CVC4::DatatypeType tt = m_context.mkTupleType(cvc4Sort(tupleSort->components));
 			CVC4::Datatype const& dt = tt.getDatatype();
 			CVC4::Expr c = dt[0].getConstructor();
 			return m_context.mkExpr(CVC4::kind::APPLY_CONSTRUCTOR, c, arguments);
 		}
 
-		solAssert(false, "");
+		smtAssert(false, "");
 	}
 	catch (CVC4::TypeCheckingException const& _e)
 	{
-		solAssert(false, _e.what());
+		smtAssert(false, _e.what());
 	}
 	catch (CVC4::Exception const& _e)
 	{
-		solAssert(false, _e.what());
+		smtAssert(false, _e.what());
 	}
 
-	solAssert(false, "");
+	smtAssert(false, "");
 }
 
 CVC4::Type CVC4Interface::cvc4Sort(Sort const& _sort)
@@ -256,7 +255,7 @@ CVC4::Type CVC4Interface::cvc4Sort(Sort const& _sort)
 	default:
 		break;
 	}
-	solAssert(false, "");
+	smtAssert(false, "");
 	// Cannot be reached.
 	return m_context.integerType();
 }

libsmtutil/Exceptions.h

@@ -0,0 +1,31 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <libsolutil/Assertions.h>
+#include <libsolutil/Exceptions.h>
+
+namespace solidity::smtutil
+{
+
+struct SMTLogicError: virtual util::Exception {};
+
+#define smtAssert(CONDITION, DESCRIPTION) \
+	assertThrow(CONDITION, SMTLogicError, DESCRIPTION)
+
+}

libsmtutil/SMTLib2Interface.cpp

@@ -63,13 +63,13 @@ void SMTLib2Interface::push()
 
 void SMTLib2Interface::pop()
 {
-	solAssert(!m_accumulatedOutput.empty(), "");
+	smtAssert(!m_accumulatedOutput.empty(), "");
 	m_accumulatedOutput.pop_back();
 }
 
 void SMTLib2Interface::declareVariable(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
+	smtAssert(_sort, "");
 	if (_sort->kind == Kind::Function)
 		declareFunction(_name, _sort);
 	else if (!m_variables.count(_name))
@@ -81,8 +81,8 @@ void SMTLib2Interface::declareVariable(string const& _name, SortPointer const& _
 
 void SMTLib2Interface::declareFunction(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
-	solAssert(_sort->kind == Kind::Function, "");
+	smtAssert(_sort, "");
+	smtAssert(_sort->kind == Kind::Function, "");
 	// TODO Use domain and codomain as key as well
 	if (!m_variables.count(_name))
 	{
@@ -139,26 +139,26 @@ string SMTLib2Interface::toSExpr(Expression const& _expr)
 	std::string sexpr = "(";
 	if (_expr.name == "const_array")
 	{
-		solAssert(_expr.arguments.size() == 2, "");
+		smtAssert(_expr.arguments.size() == 2, "");
 		auto sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments.at(0).sort);
-		solAssert(sortSort, "");
+		smtAssert(sortSort, "");
 		auto arraySort = dynamic_pointer_cast<ArraySort>(sortSort->inner);
-		solAssert(arraySort, "");
+		smtAssert(arraySort, "");
 		sexpr += "(as const " + toSmtLibSort(*arraySort) + ") ";
 		sexpr += toSExpr(_expr.arguments.at(1));
 	}
 	else if (_expr.name == "tuple_get")
 	{
-		solAssert(_expr.arguments.size() == 2, "");
+		smtAssert(_expr.arguments.size() == 2, "");
 		auto tupleSort = dynamic_pointer_cast<TupleSort>(_expr.arguments.at(0).sort);
 		unsigned index = std::stoi(_expr.arguments.at(1).name);
-		solAssert(index < tupleSort->members.size(), "");
+		smtAssert(index < tupleSort->members.size(), "");
 		sexpr += "|" + tupleSort->members.at(index) + "| " + toSExpr(_expr.arguments.at(0));
 	}
 	else if (_expr.name == "tuple_constructor")
 	{
 		auto tupleSort = dynamic_pointer_cast<TupleSort>(_expr.sort);
-		solAssert(tupleSort, "");
+		smtAssert(tupleSort, "");
 		sexpr += "|" + tupleSort->name + "|";
 		for (auto const& arg: _expr.arguments)
 			sexpr += " " + toSExpr(arg);
@@ -184,7 +184,7 @@ string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 	case Kind::Array:
 	{
 		auto const& arraySort = dynamic_cast<ArraySort const&>(_sort);
-		solAssert(arraySort.domain && arraySort.range, "");
+		smtAssert(arraySort.domain && arraySort.range, "");
 		return "(Array " + toSmtLibSort(*arraySort.domain) + ' ' + toSmtLibSort(*arraySort.range) + ')';
 	}
 	case Kind::Tuple:
@@ -195,7 +195,7 @@ string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 		{
 			m_userSorts.insert(tupleName);
 			string decl("(declare-datatypes ((" + tupleName + " 0)) (((" + tupleName);
-			solAssert(tupleSort.members.size() == tupleSort.components.size(), "");
+			smtAssert(tupleSort.members.size() == tupleSort.components.size(), "");
 			for (unsigned i = 0; i < tupleSort.members.size(); ++i)
 				decl += " (|" + tupleSort.members.at(i) + "| " + toSmtLibSort(*tupleSort.components.at(i)) + ")";
 			decl += "))))";
@@ -205,7 +205,7 @@ string SMTLib2Interface::toSmtLibSort(Sort const& _sort)
 		return tupleName;
 	}
 	default:
-		solAssert(false, "Invalid SMT sort");
+		smtAssert(false, "Invalid SMT sort");
 	}
 }
 
@@ -220,7 +220,7 @@ string SMTLib2Interface::toSmtLibSort(vector<SortPointer> const& _sorts)
 
 void SMTLib2Interface::write(string _data)
 {
-	solAssert(!m_accumulatedOutput.empty(), "");
+	smtAssert(!m_accumulatedOutput.empty(), "");
 	m_accumulatedOutput.back() += move(_data) + "\n";
 }
 
@@ -235,7 +235,7 @@ string SMTLib2Interface::checkSatAndGetValuesCommand(vector<Expression> const& _
 		for (size_t i = 0; i < _expressionsToEvaluate.size(); i++)
 		{
 			auto const& e = _expressionsToEvaluate.at(i);
-			solAssert(e.sort->kind == Kind::Int || e.sort->kind == Kind::Bool, "Invalid sort for expression to evaluate.");
+			smtAssert(e.sort->kind == Kind::Int || e.sort->kind == Kind::Bool, "Invalid sort for expression to evaluate.");
 			command += "(declare-const |EVALEXPR_" + to_string(i) + "| " + (e.sort->kind == Kind::Int ? "Int" : "Bool") + ")\n";
 			command += "(assert (= |EVALEXPR_" + to_string(i) + "| " + toSExpr(e) + "))\n";
 		}

libsmtutil/SMTLib2Interface.h

@@ -20,7 +20,7 @@
 #include <libsmtutil/SolverInterface.h>
 
 #include <libsolidity/interface/ReadFile.h>
-#include <liblangutil/Exceptions.h>
+
 #include <libsolutil/Common.h>
 #include <libsolutil/FixedHash.h>
 

libsmtutil/SMTPortfolio.cpp

@@ -68,7 +68,7 @@ void SMTPortfolio::pop()
 
 void SMTPortfolio::declareVariable(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
+	smtAssert(_sort, "");
 	for (auto const& s: m_solvers)
 		s->declareVariable(_name, _sort);
 }
@@ -141,8 +141,8 @@ vector<string> SMTPortfolio::unhandledQueries()
 {
 	// This code assumes that the constructor guarantees that
 	// SmtLib2Interface is in position 0.
-	solAssert(!m_solvers.empty(), "");
-	solAssert(dynamic_cast<SMTLib2Interface*>(m_solvers.front().get()), "");
+	smtAssert(!m_solvers.empty(), "");
+	smtAssert(dynamic_cast<SMTLib2Interface*>(m_solvers.front().get()), "");
 	return m_solvers.front()->unhandledQueries();
 }
 

libsmtutil/SolverInterface.h

@@ -17,11 +17,10 @@
 
 #pragma once
 
+#include <libsmtutil/Exceptions.h>
 #include <libsmtutil/Sorts.h>
 
-#include <liblangutil/Exceptions.h>
 #include <libsolutil/Common.h>
-#include <libsolutil/Exceptions.h>
 
 #include <boost/noncopyable.hpp>
 #include <cstdio>
@@ -75,7 +74,7 @@ public:
 		if (name == "tuple_constructor")
 		{
 			auto tupleSort = std::dynamic_pointer_cast<TupleSort>(sort);
-			solAssert(tupleSort, "");
+			smtAssert(tupleSort, "");
 			return arguments.size() == tupleSort->components.size();
 		}
 
@@ -105,7 +104,7 @@ public:
 
 	static Expression ite(Expression _condition, Expression _trueValue, Expression _falseValue)
 	{
-		solAssert(*_trueValue.sort == *_falseValue.sort, "");
+		smtAssert(*_trueValue.sort == *_falseValue.sort, "");
 		SortPointer sort = _trueValue.sort;
 		return Expression("ite", std::vector<Expression>{
 			std::move(_condition), std::move(_trueValue), std::move(_falseValue)
@@ -125,11 +124,11 @@ public:
 	/// select is the SMT representation of an array index access.
 	static Expression select(Expression _array, Expression _index)
 	{
-		solAssert(_array.sort->kind == Kind::Array, "");
+		smtAssert(_array.sort->kind == Kind::Array, "");
 		std::shared_ptr<ArraySort> arraySort = std::dynamic_pointer_cast<ArraySort>(_array.sort);
-		solAssert(arraySort, "");
-		solAssert(_index.sort, "");
-		solAssert(*arraySort->domain == *_index.sort, "");
+		smtAssert(arraySort, "");
+		smtAssert(_index.sort, "");
+		smtAssert(*arraySort->domain == *_index.sort, "");
 		return Expression(
 			"select",
 			std::vector<Expression>{std::move(_array), std::move(_index)},
@@ -142,11 +141,11 @@ public:
 	static Expression store(Expression _array, Expression _index, Expression _element)
 	{
 		auto arraySort = std::dynamic_pointer_cast<ArraySort>(_array.sort);
-		solAssert(arraySort, "");
-		solAssert(_index.sort, "");
-		solAssert(_element.sort, "");
-		solAssert(*arraySort->domain == *_index.sort, "");
-		solAssert(*arraySort->range == *_element.sort, "");
+		smtAssert(arraySort, "");
+		smtAssert(_index.sort, "");
+		smtAssert(_element.sort, "");
+		smtAssert(*arraySort->domain == *_index.sort, "");
+		smtAssert(*arraySort->range == *_element.sort, "");
 		return Expression(
 			"store",
 			std::vector<Expression>{std::move(_array), std::move(_index), std::move(_element)},
@@ -156,12 +155,12 @@ public:
 
 	static Expression const_array(Expression _sort, Expression _value)
 	{
-		solAssert(_sort.sort->kind == Kind::Sort, "");
+		smtAssert(_sort.sort->kind == Kind::Sort, "");
 		auto sortSort = std::dynamic_pointer_cast<SortSort>(_sort.sort);
 		auto arraySort = std::dynamic_pointer_cast<ArraySort>(sortSort->inner);
-		solAssert(sortSort && arraySort, "");
-		solAssert(_value.sort, "");
-		solAssert(*arraySort->range == *_value.sort, "");
+		smtAssert(sortSort && arraySort, "");
+		smtAssert(_value.sort, "");
+		smtAssert(*arraySort->range == *_value.sort, "");
 		return Expression(
 			"const_array",
 			std::vector<Expression>{std::move(_sort), std::move(_value)},
@@ -171,10 +170,10 @@ public:
 
 	static Expression tuple_get(Expression _tuple, size_t _index)
 	{
-		solAssert(_tuple.sort->kind == Kind::Tuple, "");
+		smtAssert(_tuple.sort->kind == Kind::Tuple, "");
 		std::shared_ptr<TupleSort> tupleSort = std::dynamic_pointer_cast<TupleSort>(_tuple.sort);
-		solAssert(tupleSort, "");
-		solAssert(_index < tupleSort->components.size(), "");
+		smtAssert(tupleSort, "");
+		smtAssert(_index < tupleSort->components.size(), "");
 		return Expression(
 			"tuple_get",
 			std::vector<Expression>{std::move(_tuple), Expression(_index)},
@@ -184,11 +183,11 @@ public:
 
 	static Expression tuple_constructor(Expression _tuple, std::vector<Expression> _arguments)
 	{
-		solAssert(_tuple.sort->kind == Kind::Sort, "");
+		smtAssert(_tuple.sort->kind == Kind::Sort, "");
 		auto sortSort = std::dynamic_pointer_cast<SortSort>(_tuple.sort);
 		auto tupleSort = std::dynamic_pointer_cast<TupleSort>(sortSort->inner);
-		solAssert(tupleSort, "");
-		solAssert(_arguments.size() == tupleSort->components.size(), "");
+		smtAssert(tupleSort, "");
+		smtAssert(_arguments.size() == tupleSort->components.size(), "");
 		return Expression(
 			"tuple_constructor",
 			std::move(_arguments),
@@ -254,12 +253,12 @@ public:
 	}
 	Expression operator()(std::vector<Expression> _arguments) const
 	{
-		solAssert(
+		smtAssert(
 			sort->kind == Kind::Function,
 			"Attempted function application to non-function."
 		);
 		auto fSort = dynamic_cast<FunctionSort const*>(sort.get());
-		solAssert(fSort, "");
+		smtAssert(fSort, "");
 		return Expression(name, std::move(_arguments), fSort->codomain);
 	}
 
@@ -297,7 +296,7 @@ public:
 	Expression newVariable(std::string _name, SortPointer const& _sort)
 	{
 		// Subclasses should do something here
-		solAssert(_sort, "");
+		smtAssert(_sort, "");
 		declareVariable(_name, _sort);
 		return Expression(std::move(_name), {}, _sort);
 	}

libsmtutil/Sorts.h

@@ -17,9 +17,9 @@
 
 #pragma once
 
-#include <liblangutil/Exceptions.h>
+#include <libsmtutil/Exceptions.h>
+
 #include <libsolutil/Common.h>
-#include <libsolutil/Exceptions.h>
 
 #include <memory>
 #include <vector>
@@ -57,7 +57,7 @@ struct FunctionSort: public Sort
 		if (!Sort::operator==(_other))
 			return false;
 		auto _otherFunction = dynamic_cast<FunctionSort const*>(&_other);
-		solAssert(_otherFunction, "");
+		smtAssert(_otherFunction, "");
 		if (domain.size() != _otherFunction->domain.size())
 			return false;
 		if (!std::equal(
@@ -67,8 +67,8 @@ struct FunctionSort: public Sort
 			[&](SortPointer _a, SortPointer _b) { return *_a == *_b; }
 		))
 			return false;
-		solAssert(codomain, "");
-		solAssert(_otherFunction->codomain, "");
+		smtAssert(codomain, "");
+		smtAssert(_otherFunction->codomain, "");
 		return *codomain == *_otherFunction->codomain;
 	}
 
@@ -87,11 +87,11 @@ struct ArraySort: public Sort
 		if (!Sort::operator==(_other))
 			return false;
 		auto _otherArray = dynamic_cast<ArraySort const*>(&_other);
-		solAssert(_otherArray, "");
-		solAssert(_otherArray->domain, "");
-		solAssert(_otherArray->range, "");
-		solAssert(domain, "");
-		solAssert(range, "");
+		smtAssert(_otherArray, "");
+		smtAssert(_otherArray->domain, "");
+		smtAssert(_otherArray->range, "");
+		smtAssert(domain, "");
+		smtAssert(range, "");
 		return *domain == *_otherArray->domain && *range == *_otherArray->range;
 	}
 
@@ -107,9 +107,9 @@ struct SortSort: public Sort
 		if (!Sort::operator==(_other))
 			return false;
 		auto _otherSort = dynamic_cast<SortSort const*>(&_other);
-		solAssert(_otherSort, "");
-		solAssert(_otherSort->inner, "");
-		solAssert(inner, "");
+		smtAssert(_otherSort, "");
+		smtAssert(_otherSort->inner, "");
+		smtAssert(inner, "");
 		return *inner == *_otherSort->inner;
 	}
 
@@ -134,7 +134,7 @@ struct TupleSort: public Sort
 		if (!Sort::operator==(_other))
 			return false;
 		auto _otherTuple = dynamic_cast<TupleSort const*>(&_other);
-		solAssert(_otherTuple, "");
+		smtAssert(_otherTuple, "");
 		if (name != _otherTuple->name)
 			return false;
 		if (members != _otherTuple->members)

libsmtutil/Z3CHCInterface.cpp

@@ -17,7 +17,6 @@
 
 #include <libsmtutil/Z3CHCInterface.h>
 
-#include <liblangutil/Exceptions.h>
 #include <libsolutil/CommonIO.h>
 
 using namespace std;
@@ -48,7 +47,7 @@ Z3CHCInterface::Z3CHCInterface():
 
 void Z3CHCInterface::declareVariable(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
+	smtAssert(_sort, "");
 	m_z3Interface->declareVariable(_name, _sort);
 }
 

libsmtutil/Z3Interface.cpp

@@ -17,7 +17,6 @@
 
 #include <libsmtutil/Z3Interface.h>
 
-#include <liblangutil/Exceptions.h>
 #include <libsolutil/CommonIO.h>
 
 using namespace std;
@@ -50,7 +49,7 @@ void Z3Interface::pop()
 
 void Z3Interface::declareVariable(string const& _name, SortPointer const& _sort)
 {
-	solAssert(_sort, "");
+	smtAssert(_sort, "");
 	if (_sort->kind == Kind::Function)
 		declareFunction(_name, *_sort);
 	else if (m_constants.count(_name))
@@ -61,7 +60,7 @@ void Z3Interface::declareVariable(string const& _name, SortPointer const& _sort)
 
 void Z3Interface::declareFunction(string const& _name, Sort const& _sort)
 {
-	solAssert(_sort.kind == Kind::Function, "");
+	smtAssert(_sort.kind == Kind::Function, "");
 	FunctionSort fSort = dynamic_cast<FunctionSort const&>(_sort);
 	if (m_functions.count(_name))
 		m_functions.at(_name) = m_context.function(_name.c_str(), z3Sort(fSort.domain), z3Sort(*fSort.codomain));
@@ -124,7 +123,7 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 			return m_functions.at(n)(arguments);
 		else if (m_constants.count(n))
 		{
-			solAssert(arguments.empty(), "");
+			smtAssert(arguments.empty(), "");
 			return m_constants.at(n);
 		}
 		else if (arguments.empty())
@@ -136,7 +135,7 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 			else if (_expr.sort->kind == Kind::Sort)
 			{
 				auto sortSort = dynamic_pointer_cast<SortSort>(_expr.sort);
-				solAssert(sortSort, "");
+				smtAssert(sortSort, "");
 				return m_context.constant(n.c_str(), z3Sort(*sortSort->inner));
 			}
 			else
@@ -146,11 +145,11 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 				}
 				catch (z3::exception const& _e)
 				{
-					solAssert(false, _e.msg());
+					smtAssert(false, _e.msg());
 				}
 		}
 
-		solAssert(_expr.hasCorrectArity(), "");
+		smtAssert(_expr.hasCorrectArity(), "");
 		if (n == "ite")
 			return z3::ite(arguments[0], arguments[1], arguments[2]);
 		else if (n == "not")
@@ -188,9 +187,9 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 		else if (n == "const_array")
 		{
 			shared_ptr<SortSort> sortSort = std::dynamic_pointer_cast<SortSort>(_expr.arguments[0].sort);
-			solAssert(sortSort, "");
+			smtAssert(sortSort, "");
 			auto arraySort = dynamic_pointer_cast<ArraySort>(sortSort->inner);
-			solAssert(arraySort && arraySort->domain, "");
+			smtAssert(arraySort && arraySort->domain, "");
 			return z3::const_array(z3Sort(*arraySort->domain), arguments[1]);
 		}
 		else if (n == "tuple_get")
@@ -201,21 +200,21 @@ z3::expr Z3Interface::toZ3Expr(Expression const& _expr)
 		else if (n == "tuple_constructor")
 		{
 			auto constructor = z3::func_decl(m_context, Z3_get_tuple_sort_mk_decl(m_context, z3Sort(*_expr.sort)));
-			solAssert(constructor.arity() == arguments.size(), "");
+			smtAssert(constructor.arity() == arguments.size(), "");
 			z3::expr_vector args(m_context);
 			for (auto const& arg: arguments)
 				args.push_back(arg);
 			return constructor(args);
 		}
 
-		solAssert(false, "");
+		smtAssert(false, "");
 	}
 	catch (z3::exception const& _e)
 	{
-		solAssert(false, _e.msg());
+		smtAssert(false, _e.msg());
 	}
 
-	solAssert(false, "");
+	smtAssert(false, "");
 }
 
 z3::sort Z3Interface::z3Sort(Sort const& _sort)
@@ -256,7 +255,7 @@ z3::sort Z3Interface::z3Sort(Sort const& _sort)
 	default:
 		break;
 	}
-	solAssert(false, "");
+	smtAssert(false, "");
 	// Cannot be reached.
 	return m_context.int_sort();
 }