cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fixup! Type inference draft.

Browse Source
This commit is contained in:
Kamil Śliwak 2023-09-28 15:19:15 +02:00
parent ef4864c576
commit e5915eac21
1 changed files with 59 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
libsolidity/experimental/analysis/TypeInference.cpp
View File

@ -45,8 +45,10 @@ TypeInference::TypeInference(Analysis& _analysis):
m_errorReporter(_analysis.errorReporter()), m_errorReporter(_analysis.errorReporter()),
m_typeSystem(_analysis.typeSystem()) m_typeSystem(_analysis.typeSystem())
{ {
auto declareBuiltinClass = [&](std::string _name, BuiltinClass _class, auto _memberCreator, Sort _sort = {}) -> TypeClass { TypeSystemHelpers helper{m_typeSystem};
Type type = m_typeSystem.freshTypeVariable(std::move(_sort));
auto declareBuiltinClass = [&](std::string _name, BuiltinClass _class) -> TypeClass {
Type type = m_typeSystem.freshTypeVariable({});
auto result = m_typeSystem.declareTypeClass( auto result = m_typeSystem.declareTypeClass(
type, type,
_name, _name,
@ -56,59 +58,74 @@ TypeInference::TypeInference(Analysis& _analysis):
solAssert(!error, *error); solAssert(!error, *error);
TypeClass declaredClass = std::get<TypeClass>(result); TypeClass declaredClass = std::get<TypeClass>(result);
// TODO: validation? // TODO: validation?
annotation().typeClassFunctions[declaredClass] = _memberCreator(type);
solAssert(annotation().builtinClassesByName.emplace(_name, _class).second); solAssert(annotation().builtinClassesByName.emplace(_name, _class).second);
return annotation().builtinClasses.emplace(_class, declaredClass).first->second; return annotation().builtinClasses.emplace(_class, declaredClass).first->second;
}; };
TypeSystemHelpers helper{m_typeSystem};
using MemberList = std::map<std::string, Type>;
declareBuiltinClass("integer", BuiltinClass::Integer, [&](Type _typeVar) -> MemberList { auto registeredTypeClass = [&](BuiltinClass _builtinClass) -> TypeClass {
return { return annotation().builtinClasses.at(_builtinClass);
{
"fromInteger",
helper.functionType(m_typeSystem.type(PrimitiveType::Integer, {}), _typeVar)
}
};
});
auto defineBinaryMonoidalOperator = [&](std::string _className, BuiltinClass _class, Token _token, std::string _functionName) {
TypeClass typeClass = declareBuiltinClass(_className, _class, [&](Type _typeVar) -> MemberList {
return {
{
_functionName,
helper.functionType(helper.tupleType({_typeVar, _typeVar}), _typeVar)
}
};
});
annotation().operators.emplace(_token, std::make_tuple(typeClass, _functionName));
}; };
defineBinaryMonoidalOperator("*", BuiltinClass::Mul, Token::Mul, "mul"); auto defineConversion = [&](BuiltinClass _builtinClass, PrimitiveType _fromType, std::string _functionName) {
defineBinaryMonoidalOperator("+", BuiltinClass::Add, Token::Add, "add"); annotation().typeClassFunctions[registeredTypeClass(_builtinClass)] = {{
std::move(_functionName),
auto defineBinaryCompareOperator = [&](std::string _className, BuiltinClass _class, Token _token, std::string _functionName) { helper.functionType(
TypeClass typeClass = declareBuiltinClass(_className, _class, [&](Type _typeVar) -> MemberList { m_typeSystem.type(_fromType, {}),
return { m_typeSystem.typeClassInfo(registeredTypeClass(_builtinClass)).typeVariable
{ ),
_functionName, }};
helper.functionType(helper.tupleType({_typeVar, _typeVar}), m_typeSystem.type(PrimitiveType::Bool, {}))
}
};
});
annotation().operators.emplace(_token, std::make_tuple(typeClass, _functionName));
}; };
defineBinaryCompareOperator("==", BuiltinClass::Equal, Token::Equal, "eq");
defineBinaryCompareOperator("<", BuiltinClass::Less, Token::LessThan, "lt"); auto defineBinaryMonoidalOperator = [&](BuiltinClass _builtinClass, Token _token, std::string _functionName) {
defineBinaryCompareOperator("<=", BuiltinClass::LessOrEqual, Token::LessThanOrEqual, "leq"); Type typeVar = m_typeSystem.typeClassInfo(registeredTypeClass(_builtinClass)).typeVariable;
defineBinaryCompareOperator(">", BuiltinClass::Greater, Token::GreaterThan, "gt"); annotation().operators.emplace(_token, std::make_tuple(registeredTypeClass(_builtinClass), _functionName));
defineBinaryCompareOperator(">=", BuiltinClass::GreaterOrEqual, Token::GreaterThanOrEqual, "geq"); annotation().typeClassFunctions[registeredTypeClass(_builtinClass)] = {{
std::move(_functionName),
helper.functionType(
helper.tupleType({typeVar, typeVar}),
typeVar
)
}};
};
auto defineBinaryCompareOperator = [&](BuiltinClass _builtinClass, Token _token, std::string _functionName) {
Type typeVar = m_typeSystem.typeClassInfo(registeredTypeClass(_builtinClass)).typeVariable;
annotation().operators.emplace(_token, std::make_tuple(registeredTypeClass(_builtinClass), _functionName));
annotation().typeClassFunctions[registeredTypeClass(_builtinClass)] = {{
std::move(_functionName),
helper.functionType(
helper.tupleType({typeVar, typeVar}),
m_typeSystem.type(PrimitiveType::Bool, {})
)
}};
};
declareBuiltinClass("integer", BuiltinClass::Integer);
declareBuiltinClass("*", BuiltinClass::Mul);
declareBuiltinClass("+", BuiltinClass::Add);
declareBuiltinClass("==", BuiltinClass::Equal);
declareBuiltinClass("<", BuiltinClass::Less);
declareBuiltinClass("<=", BuiltinClass::LessOrEqual);
declareBuiltinClass(">", BuiltinClass::Greater);
declareBuiltinClass(">=", BuiltinClass::GreaterOrEqual);
defineConversion(BuiltinClass::Integer, PrimitiveType::Integer, "fromInteger");
defineBinaryMonoidalOperator(BuiltinClass::Mul, Token::Mul, "mul");
defineBinaryMonoidalOperator(BuiltinClass::Add, Token::Add, "add");
defineBinaryCompareOperator(BuiltinClass::Equal, Token::Equal, "eq");
defineBinaryCompareOperator(BuiltinClass::Less, Token::LessThan, "lt");
defineBinaryCompareOperator(BuiltinClass::LessOrEqual, Token::LessThanOrEqual, "leq");
defineBinaryCompareOperator(BuiltinClass::Greater, Token::GreaterThan, "gt");
defineBinaryCompareOperator(BuiltinClass::GreaterOrEqual, Token::GreaterThanOrEqual, "geq");
m_voidType = m_typeSystem.type(PrimitiveType::Void, {}); m_voidType = m_typeSystem.type(PrimitiveType::Void, {});
m_wordType = m_typeSystem.type(PrimitiveType::Word, {}); m_wordType = m_typeSystem.type(PrimitiveType::Word, {});
m_integerType = m_typeSystem.type(PrimitiveType::Integer, {}); m_integerType = m_typeSystem.type(PrimitiveType::Integer, {});
m_unitType = m_typeSystem.type(PrimitiveType::Unit, {}); m_unitType = m_typeSystem.type(PrimitiveType::Unit, {});
m_boolType = m_typeSystem.type(PrimitiveType::Bool, {}); m_boolType = m_typeSystem.type(PrimitiveType::Bool, {});
m_env = &m_typeSystem.env(); m_env = &m_typeSystem.env();
{ {