Use shared_from_this instead of manually supplying a shared_ptr to this.

3 files changed, 26 insertions, 57 deletions

diff --git a/AST.cpp b/AST.cpp
index 1247f325..bcaae0e1 100644
--- a/AST.cpp
+++ b/AST.cpp
@@ -193,8 +193,8 @@ void Assignment::checkTypeRequirements()
 	{
 		// compound assignment
 		m_rightHandSide->checkTypeRequirements();
-		TypePointer resultType = Type::binaryOperatorResult(Token::AssignmentToBinaryOp(m_assigmentOperator),
-															m_type, m_rightHandSide->getType());
+		TypePointer resultType = m_type->binaryOperatorResult(Token::AssignmentToBinaryOp(m_assigmentOperator),
+															  m_rightHandSide->getType());
 		if (!resultType || *resultType != *m_type)
 			BOOST_THROW_EXCEPTION(createTypeError("Operator not compatible with type."));
 	}
@@ -237,7 +237,7 @@ void BinaryOperation::checkTypeRequirements()
 {
 	m_left->checkTypeRequirements();
 	m_right->checkTypeRequirements();
-	m_commonType = Type::binaryOperatorResult(m_operator, m_left->getType(), m_right->getType());
+	m_commonType = m_left->getType()->binaryOperatorResult(m_operator, m_right->getType());
 	if (!m_commonType)
 		BOOST_THROW_EXCEPTION(createTypeError("Operator " + string(Token::toString(m_operator)) +
 											  " not compatible with types " +
diff --git a/Types.cpp b/Types.cpp
index 01fa7734..d1a3c7a7 100644
--- a/Types.cpp
+++ b/Types.cpp
@@ -192,11 +192,11 @@ u256 IntegerType::literalValue(Literal const& _literal) const
 	return u256(value);
 }
 
-TypePointer IntegerType::binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const
+TypePointer IntegerType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
 {
 	if (getCategory() != _other->getCategory())
 		return TypePointer();
-	auto commonType = dynamic_pointer_cast<IntegerType const>(Type::commonType(_this, _other));
+	auto commonType = dynamic_pointer_cast<IntegerType const>(Type::commonType(shared_from_this(), _other));
 
 	if (!commonType)
 		return TypePointer();
@@ -288,12 +288,12 @@ u256 BoolType::literalValue(Literal const& _literal) const
 		BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Bool type constructed from non-boolean literal."));
 }
 
-TypePointer BoolType::binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const
+TypePointer BoolType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
 {
 	if (getCategory() != _other->getCategory())
 		return TypePointer();
 	if (Token::isCompareOp(_operator) || _operator == Token::AND || _operator == Token::OR)
-		return _this;
+		return _other;
 	else
 		return TypePointer();
 }
diff --git a/Types.h b/Types.h
index e50cbc0a..3b416f40 100644
--- a/Types.h
+++ b/Types.h
@@ -70,7 +70,7 @@ private:
 /**
  * Abstract base class that forms the root of the type hierarchy.
  */
-class Type: private boost::noncopyable
+class Type: private boost::noncopyable, public std::enable_shared_from_this<Type>
 {
 public:
 	enum class Category
@@ -92,12 +92,6 @@ public:
 	static TypePointer forLiteral(Literal const& _literal);
 	/// @returns a pointer to _a or _b if the other is implicitly convertible to it or nullptr otherwise
 	static TypePointer commonType(TypePointer const& _a, TypePointer const& _b);
-	/// @returns the resulting type of applying the given operator or an empty pointer if this is not possible.
-	/// The default implementation allows comparison operators if a common type exists
-	static TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _a, TypePointer const& _b)
-	{
-		return _a->binaryOperatorResultImpl(_operator, _a, _b);
-	}
 
 	virtual Category getCategory() const = 0;
 	virtual bool isImplicitlyConvertibleTo(Type const& _other) const { return *this == _other; }
@@ -106,6 +100,13 @@ public:
 		return isImplicitlyConvertibleTo(_convertTo);
 	}
 	virtual bool acceptsUnaryOperator(Token::Value) const { return false; }
+	/// @returns the resulting type of applying the given binary operator or an empty pointer if
+	/// this is not possible.
+	/// The default implementation allows comparison operators if a common type exists
+	virtual TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
+	{
+		return Token::isCompareOp(_operator) ? commonType(shared_from_this(), _other) : TypePointer();
+	}
 
 	virtual bool operator==(Type const& _other) const { return getCategory() == _other.getCategory(); }
 	virtual bool operator!=(Type const& _other) const { return !this->operator ==(_other); }
@@ -138,11 +139,6 @@ public:
 	}
 
 protected:
-	virtual TypePointer binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _a, TypePointer const& _b) const
-	{
-		return Token::isCompareOp(_operator) ? commonType(_a, _b) : TypePointer();
-	}
-
 	/// Convenience object used when returning an empty member list.
 	static const MemberList EmptyMemberList;
 };
@@ -168,6 +164,7 @@ public:
 	virtual bool isImplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual bool acceptsUnaryOperator(Token::Value _operator) const override;
+	virtual TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const override;
 
 	virtual bool operator==(Type const& _other) const override;
 
@@ -184,9 +181,6 @@ public:
 	bool isAddress() const { return m_modifier == Modifier::ADDRESS; }
 	int isSigned() const { return m_modifier == Modifier::SIGNED; }
 
-protected:
-	virtual TypePointer binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const override;
-
 private:
 	int m_bits;
 	Modifier m_modifier;
@@ -235,15 +229,13 @@ public:
 	{
 		return _operator == Token::NOT || _operator == Token::DELETE;
 	}
+	virtual TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const override;
 
 	virtual unsigned getCalldataEncodedSize() const { return 1; }
 	virtual bool isValueType() const override { return true; }
 
 	virtual std::string toString() const override { return "bool"; }
 	virtual u256 literalValue(Literal const& _literal) const override;
-
-protected:
-	virtual TypePointer binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const override;
 };
 
 /**
@@ -285,10 +277,7 @@ class StructType: public Type
 public:
 	virtual Category getCategory() const override { return Category::STRUCT; }
 	StructType(StructDefinition const& _struct): m_struct(_struct) {}
-	virtual bool acceptsUnaryOperator(Token::Value _operator) const override
-	{
-		return _operator == Token::DELETE;
-	}
+	virtual bool acceptsUnaryOperator(Token::Value _operator) const override { return _operator == Token::DELETE; }
 
 	virtual bool operator==(Type const& _other) const override;
 	virtual u256 getStorageSize() const override;
@@ -378,20 +367,12 @@ public:
 	virtual Category getCategory() const override { return Category::VOID; }
 	VoidType() {}
 
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
 	virtual std::string toString() const override { return "void"; }
 	virtual bool canBeStored() const override { return false; }
 	virtual u256 getStorageSize() const override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable void type requested.")); }
 	virtual bool canLiveOutsideStorage() const override { return false; }
 	virtual unsigned getSizeOnStack() const override { return 0; }
-
-protected:
-	virtual TypePointer binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const override
-	{
-		(void)_operator;
-		(void)_this;
-		(void)_other;
-		return TypePointer();
-	}
 };
 
 /**
@@ -403,24 +384,15 @@ class TypeType: public Type
 public:
 	virtual Category getCategory() const override { return Category::TYPE; }
 	TypeType(TypePointer const& _actualType): m_actualType(_actualType) {}
-
 	TypePointer const& getActualType() const { return m_actualType; }
 
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
 	virtual bool operator==(Type const& _other) const override;
 	virtual bool canBeStored() const override { return false; }
 	virtual u256 getStorageSize() const override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Storage size of non-storable type type requested.")); }
 	virtual bool canLiveOutsideStorage() const override { return false; }
 	virtual std::string toString() const override { return "type(" + m_actualType->toString() + ")"; }
 
-protected:
-	virtual TypePointer binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const override
-	{
-		(void)_operator;
-		(void)_this;
-		(void)_other;
-		return TypePointer();
-	}
-
 private:
 	TypePointer m_actualType;
 };
@@ -437,6 +409,12 @@ public:
 	virtual Category getCategory() const override { return Category::MAGIC; }
 
 	MagicType(Kind _kind);
+
+	virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override
+	{
+		return TypePointer();
+	}
+
 	virtual bool operator==(Type const& _other) const;
 	virtual bool canBeStored() const override { return false; }
 	virtual bool canLiveOutsideStorage() const override { return true; }
@@ -445,15 +423,6 @@ public:
 
 	virtual std::string toString() const override;
 
-protected:
-	virtual TypePointer binaryOperatorResultImpl(Token::Value _operator, TypePointer const& _this, TypePointer const& _other) const override
-	{
-		(void)_operator;
-		(void)_this;
-		(void)_other;
-		return TypePointer();
-	}
-
 private:
 	Kind m_kind;