Compute stack slots for primitive types

Author: r0qs

Diff for: libsolidity/experimental/analysis/TypeInference.cpp

@@ -807,6 +807,7 @@ bool TypeInference::visit(TypeDefinition const& _typeDefinition)
 	{
 		members->second.emplace("abs", TypeMember{helper.functionType(*underlyingType, definedType)});
 		members->second.emplace("rep", TypeMember{helper.functionType(definedType, *underlyingType)});
+		annotation().underlyingTypes[constructor] = *underlyingType;
 	}
 
 	if (helper.isPrimitiveType(definedType, PrimitiveType::Pair))

Diff for: libsolidity/experimental/analysis/TypeInference.h

@@ -50,6 +50,7 @@ class TypeInference: public ASTConstVisitor
 		std::map<TypeClass, std::map<std::string, Type>> typeClassFunctions;
 		std::map<Token, std::tuple<TypeClass, std::string>> operators;
 		std::map<TypeConstructor, std::map<std::string, TypeMember>> members;
+		std::map<TypeConstructor, Type> underlyingTypes;
 	};
 	bool visit(Block const&) override { return true; }
 	bool visit(VariableDeclarationStatement const&) override { return true; }

Diff for: libsolidity/experimental/codegen/IRGeneratorForStatements.cpp

@@ -119,7 +119,7 @@ bool IRGeneratorForStatements::visit(TupleExpression const& _tupleExpression)
 	{
 		solUnimplementedAssert(component);
 		component->accept(*this);
-		components.emplace_back(var(*component).name());
+		components.emplace_back(var(*component).commaSeparatedList());
 	}
 
 	solUnimplementedAssert(false, "No support for tuples.");
@@ -205,7 +205,6 @@ void IRGeneratorForStatements::endVisit(BinaryOperation const& _binaryOperation)
 	// TODO: get around resolveRecursive by passing the environment further down?
 	functionType = m_context.env->resolveRecursive(functionType);
 	m_context.enqueueFunctionDefinition(&functionDefinition, functionType);
-	// TODO: account for return stack size
 	m_code << "let " << var(_binaryOperation).commaSeparatedList() <<
 		" := " << IRNames::function(*m_context.env, functionDefinition, functionType) << "(" <<
 		var(_binaryOperation.leftExpression()).commaSeparatedList() <<
@@ -342,14 +341,13 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 	// TODO: get around resolveRecursive by passing the environment further down?
 	functionType = m_context.env->resolveRecursive(functionType);
 	m_context.enqueueFunctionDefinition(functionDefinition, functionType);
-	// TODO: account for return stack size
-	m_code << "let " << var(_functionCall).name() << " := " << IRNames::function(*m_context.env, *functionDefinition, functionType) << "(";
+	m_code << "let " << var(_functionCall).commaSeparatedList() << " := " << IRNames::function(*m_context.env, *functionDefinition, functionType) << "(";
 	auto const& arguments = _functionCall.arguments();
 	if (arguments.size() > 1)
 		for (auto arg: arguments | ranges::views::drop_last(1))
-			m_code << var(*arg).name() << ", ";
+			m_code << var(*arg).commaSeparatedList();
 	if (!arguments.empty())
-		m_code << var(*arguments.back()).name();
+		m_code << var(*arguments.back()).commaSeparatedListPrefixed();
 	m_code << ")\n";
 }
 

Diff for: libsolidity/experimental/codegen/IRGeneratorForStatements.h

@@ -20,6 +20,8 @@
 
 #include <libsolidity/experimental/codegen/IRGenerationContext.h>
 #include <libsolidity/experimental/codegen/IRVariable.h>
+#include <libsolidity/experimental/ast/TypeSystemHelper.h>
+#include <libsolidity/experimental/analysis/TypeInference.h>
 
 #include <libsolidity/ast/ASTVisitor.h>
 
@@ -37,10 +39,58 @@ class IRGeneratorForStatements: public ASTConstVisitor
 
 	std::string generate(ASTNode const& _node);
 
-	static std::size_t stackSize(IRGenerationContext, Type)
+	static std::size_t stackSize(IRGenerationContext const& _context, Type _type)
 	{
-		// TODO
-		return 1;
+		TypeSystemHelpers helper{_context.analysis.typeSystem()};
+		_type = _context.env->resolve(_type);
+		solAssert(std::holds_alternative<TypeConstant>(_type), "No monomorphized type.");
+
+		// type -> # stack slots
+		// unit, itself -> 0
+		// void, literals(integer), typeFunction -> error (maybe generate a revert)
+		// word, bool, function -> 1
+		// pair -> sum(stackSize(args))
+		// user-defined -> stackSize(underlying type)
+		TypeConstant typeConstant = std::get<TypeConstant>(_type);
+		if (helper.isPrimitiveType(_type, PrimitiveType::Unit) ||
+			helper.isPrimitiveType(_type, PrimitiveType::Itself))
+			return 0;
+		else if (helper.isPrimitiveType(_type, PrimitiveType::Bool) || helper.isPrimitiveType(_type, PrimitiveType::Word))
+		{
+			solAssert(typeConstant.arguments.empty(), "Primitive type Bool or Word should have no arguments.");
+			return 1;
+		}
+		else if (helper.isFunctionType(_type))
+			return 1;
+		else if (
+			helper.isPrimitiveType(_type, PrimitiveType::Integer) ||
+			helper.isPrimitiveType(_type, PrimitiveType::Void) ||
+			helper.isPrimitiveType(_type, PrimitiveType::TypeFunction))
+			solThrow(langutil::CompilerError, "Primitive type Void, Unit or TypeFunction do not have stack slot"); // FIXME: proper error
+		else if (helper.isPrimitiveType(_type, PrimitiveType::Pair))
+		{
+			solAssert(typeConstant.arguments.size() == 2);
+			return stackSize(_context, typeConstant.arguments.front()) + stackSize(_context, typeConstant.arguments.back());
+		}
+		else
+		{
+			Type underlyingType = _context.analysis.annotation<TypeInference>().underlyingTypes.at(typeConstant.constructor);
+			if (helper.isTypeConstant(underlyingType))
+				return stackSize(_context, underlyingType);
+
+			TypeEnvironment env = _context.env->clone();
+			Type genericFunctionType = helper.typeFunctionType(
+				helper.tupleType(typeConstant.arguments),
+				env.typeSystem().freshTypeVariable({}));
+			solAssert(env.unify(genericFunctionType, underlyingType).empty());
+
+			Type resolvedType = env.resolveRecursive(genericFunctionType);
+			auto [argumentType, resultType] = helper.destTypeFunctionType(resolvedType);
+			return stackSize(_context, resultType);
+		}
+
+		//TODO: sum types
+		return 0;
 	}
 
 private: