7 files changed, 100 insertions, 79 deletions

diff --git a/libsolidity/analysis/DeclarationContainer.cpp b/libsolidity/analysis/DeclarationContainer.cpp
index 786272e4..9e2bf6d3 100644
--- a/libsolidity/analysis/DeclarationContainer.cpp
+++ b/libsolidity/analysis/DeclarationContainer.cpp
@@ -96,6 +96,11 @@ void DeclarationContainer::activateVariable(ASTString const& _name)
 	m_invisibleDeclarations.erase(_name);
 }
 
+bool DeclarationContainer::isInvisible(ASTString const& _name) const
+{
+	return m_invisibleDeclarations.count(_name);
+}
+
 bool DeclarationContainer::registerDeclaration(
 	Declaration const& _declaration,
 	ASTString const* _name,
diff --git a/libsolidity/analysis/DeclarationContainer.h b/libsolidity/analysis/DeclarationContainer.h
index a3e0bd0a..9d7a17a3 100644
--- a/libsolidity/analysis/DeclarationContainer.h
+++ b/libsolidity/analysis/DeclarationContainer.h
@@ -62,6 +62,9 @@ public:
 	/// VariableDeclarationStatements.
 	void activateVariable(ASTString const& _name);
 
+	/// @returns true if declaration is currently invisible.
+	bool isInvisible(ASTString const& _name) const;
+
 	/// @returns existing declaration names similar to @a _name.
 	/// Searches this and all parent containers.
 	std::vector<ASTString> similarNames(ASTString const& _name) const;
diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp
index b856544a..7c23c992 100644
--- a/libsolidity/analysis/NameAndTypeResolver.cpp
+++ b/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -156,7 +156,13 @@ bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
 void NameAndTypeResolver::activateVariable(string const& _name)
 {
 	solAssert(m_currentScope, "");
-	m_currentScope->activateVariable(_name);
+	// Scoped local variables are invisible before activation.
+	// When a local variable is activated, its name is removed
+	// from a scope's invisible variables.
+	// This is used to avoid activation of variables of same name
+	// in the same scope (an error is returned).
+	if (m_currentScope->isInvisible(_name))
+		m_currentScope->activateVariable(_name);
 }
 
 vector<Declaration const*> NameAndTypeResolver::resolveName(ASTString const& _name, ASTNode const* _scope) const
diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp
index 63f8fac3..4311e77d 100644
--- a/libsolidity/analysis/SyntaxChecker.cpp
+++ b/libsolidity/analysis/SyntaxChecker.cpp
@@ -254,15 +254,6 @@ bool SyntaxChecker::visit(FunctionTypeName const& _node)
 	return true;
 }
 
-bool SyntaxChecker::visit(VariableDeclaration const& _declaration)
-{
-	if (!_declaration.typeName())
-	{
-		m_errorReporter.syntaxError(_declaration.location(), "Use of the \"var\" keyword is disallowed.");
-	}
-	return true;
-}
-
 bool SyntaxChecker::visit(StructDefinition const& _struct)
 {
 	if (_struct.members().empty())
diff --git a/libsolidity/analysis/SyntaxChecker.h b/libsolidity/analysis/SyntaxChecker.h
index 1579df57..8ee3df37 100644
--- a/libsolidity/analysis/SyntaxChecker.h
+++ b/libsolidity/analysis/SyntaxChecker.h
@@ -69,8 +69,6 @@ private:
 	virtual bool visit(FunctionDefinition const& _function) override;
 	virtual bool visit(FunctionTypeName const& _node) override;
 
-	virtual bool visit(VariableDeclaration const& _declaration) override;
-
 	virtual bool visit(StructDefinition const& _struct) override;
 
 	ErrorReporter& m_errorReporter;
diff --git a/libsolidity/analysis/TypeChecker.cpp b/libsolidity/analysis/TypeChecker.cpp
index a11b1879..8ea0a4d7 100644
--- a/libsolidity/analysis/TypeChecker.cpp
+++ b/libsolidity/analysis/TypeChecker.cpp
@@ -23,6 +23,7 @@
 #include <libsolidity/analysis/TypeChecker.h>
 #include <memory>
 #include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/join.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <libsolidity/ast/AST.h>
 #include <libsolidity/inlineasm/AsmAnalysis.h>
@@ -123,10 +124,7 @@ bool TypeChecker::visit(ContractDefinition const& _contract)
 				m_errorReporter.typeError(function->parameterList().location(), "Fallback function cannot take parameters.");
 			if (!function->returnParameters().empty())
 				m_errorReporter.typeError(function->returnParameterList()->location(), "Fallback function cannot return values.");
-			if (
-				_contract.sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::V050) &&
-				function->visibility() != FunctionDefinition::Visibility::External
-			)
+			if (function->visibility() != FunctionDefinition::Visibility::External)
 				m_errorReporter.typeError(function->location(), "Fallback function must be defined as \"external\".");
 		}
 
@@ -451,7 +449,7 @@ void TypeChecker::overrideError(FunctionDefinition const& function, FunctionDefi
 {
 	m_errorReporter.typeError(
 		function.location(),
-		SecondarySourceLocation().append("Overriden function is here:", super.location()),
+		SecondarySourceLocation().append("Overridden function is here:", super.location()),
 		message
 	);
 }
@@ -551,33 +549,18 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
 
 	if (arguments)
 	{
-		bool v050 = m_scope->sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::V050);
-
 		if (parameterTypes.size() != arguments->size())
 		{
-			if (arguments->size() == 0 && !v050)
-				m_errorReporter.warning(
-					_inheritance.location(),
-					"Wrong argument count for constructor call: " +
-					toString(arguments->size()) +
-					" arguments given but expected " +
-					toString(parameterTypes.size()) +
-					"."
-				);
-			else
-			{
-				m_errorReporter.typeError(
-					_inheritance.location(),
-					"Wrong argument count for constructor call: " +
-					toString(arguments->size()) +
-					" arguments given but expected " +
-					toString(parameterTypes.size()) +
-					"."
-				);
-				return;
-			}
+			m_errorReporter.typeError(
+				_inheritance.location(),
+				"Wrong argument count for constructor call: " +
+				toString(arguments->size()) +
+				" arguments given but expected " +
+				toString(parameterTypes.size()) +
+				". Remove parentheses if you do not want to provide arguments here."
+			);
 		}
-		for (size_t i = 0; i < arguments->size(); ++i)
+		for (size_t i = 0; i < std::min(arguments->size(), parameterTypes.size()); ++i)
 			if (!type(*(*arguments)[i])->isImplicitlyConvertibleTo(*parameterTypes[i]))
 				m_errorReporter.typeError(
 					(*arguments)[i]->location(),
@@ -1054,6 +1037,47 @@ void TypeChecker::endVisit(EmitStatement const& _emit)
 	m_insideEmitStatement = false;
 }
 
+namespace
+{
+/**
+ * @returns a suggested left-hand-side of a multi-variable declaration contairing
+ * the variable declarations given in @a _decls.
+ */
+string createTupleDecl(vector<VariableDeclaration const*> const& _decls)
+{
+	vector<string> components;
+	for (VariableDeclaration const* decl: _decls)
+		if (decl)
+			components.emplace_back(decl->annotation().type->toString(false) + " " + decl->name());
+		else
+			components.emplace_back();
+
+	if (_decls.size() == 1)
+		return components.front();
+	else
+		return "(" + boost::algorithm::join(components, ", ") + ")";
+}
+
+bool typeCanBeExpressed(vector<VariableDeclaration const*> const& decls)
+{
+	for (VariableDeclaration const* decl: decls)
+	{
+		// skip empty tuples (they can be expressed of course)
+		if (!decl)
+			continue;
+
+		if (auto functionType = dynamic_cast<FunctionType const*>(decl->annotation().type.get()))
+			if (
+				functionType->kind() != FunctionType::Kind::Internal &&
+				functionType->kind() != FunctionType::Kind::External
+			)
+				return false;
+	}
+
+	return true;
+}
+}
+
 bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 {
 	bool const v050 = m_scope->sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::V050);
@@ -1164,6 +1188,8 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 		else
 			assignments[assignments.size() - i - 1] = variables[variables.size() - i - 1].get();
 
+	bool autoTypeDeductionNeeded = false;
+
 	for (size_t i = 0; i < assignments.size(); ++i)
 	{
 		if (!assignments[i])
@@ -1174,6 +1200,8 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 		solAssert(!!valueComponentType, "");
 		if (!var.annotation().type)
 		{
+			autoTypeDeductionNeeded = true;
+
 			// Infer type from value.
 			solAssert(!var.typeName(), "");
 			var.annotation().type = valueComponentType->mobileType();
@@ -1217,14 +1245,6 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 				}
 				else
 					solAssert(dynamic_cast<FixedPointType const*>(var.annotation().type.get()), "Unknown type.");
-
-				m_errorReporter.warning(
-					_statement.location(),
-					"The type of this variable was inferred as " +
-					typeName +
-					extension +
-					". This is probably not desired. Use an explicit type to silence this warning."
-				);
 			}
 
 			var.accept(*this);
@@ -1261,6 +1281,23 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 			}
 		}
 	}
+
+	if (autoTypeDeductionNeeded)
+	{
+		if (!typeCanBeExpressed(assignments))
+			m_errorReporter.syntaxError(
+				_statement.location(),
+				"Use of the \"var\" keyword is disallowed. "
+				"Type cannot be expressed in syntax."
+			);
+		else
+			m_errorReporter.syntaxError(
+				_statement.location(),
+				"Use of the \"var\" keyword is disallowed. "
+				"Use explicit declaration `" + createTupleDecl(assignments) + " = ...´ instead."
+			);
+	}
+
 	return false;
 }
 
@@ -1408,14 +1445,12 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 	}
 	else
 	{
-		bool const v050 = m_scope->sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::V050);
 		bool isPure = true;
 		TypePointer inlineArrayType;
 
 		for (size_t i = 0; i < components.size(); ++i)
 		{
-			// Outside of an lvalue-context, the only situation where a component can be empty is (x,).
-			if (!components[i] && !(i == 1 && components.size() == 2))
+			if (!components[i])
 				m_errorReporter.fatalTypeError(_tuple.location(), "Tuple component cannot be empty.");
 			else if (components[i])
 			{
@@ -1427,10 +1462,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 					{
 						if (_tuple.isInlineArray())
 							m_errorReporter.fatalTypeError(components[i]->location(), "Array component cannot be empty.");
-						if (v050)
-							m_errorReporter.fatalTypeError(components[i]->location(), "Tuple component cannot be empty.");
-						else
-							m_errorReporter.warning(components[i]->location(), "Tuple component cannot be empty.");
+						m_errorReporter.typeError(components[i]->location(), "Tuple component cannot be empty.");
 					}
 
 				// Note: code generation will visit each of the expression even if they are not assigned from.
@@ -1468,11 +1500,7 @@ bool TypeChecker::visit(TupleExpression const& _tuple)
 			if (components.size() == 1)
 				_tuple.annotation().type = type(*components[0]);
 			else
-			{
-				if (components.size() == 2 && !components[1])
-					types.pop_back();
 				_tuple.annotation().type = make_shared<TupleType>(types);
-			}
 		}
 
 	}
@@ -1663,8 +1691,6 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 	else
 		_functionCall.annotation().type = make_shared<TupleType>(returnTypes);
 
-	bool const v050 = m_scope->sourceUnit().annotation().experimentalFeatures.count(ExperimentalFeature::V050);
-
 	if (auto functionName = dynamic_cast<Identifier const*>(&_functionCall.expression()))
 	{
 		if (functionName->name() == "sha3" && functionType->kind() == FunctionType::Kind::SHA3)
@@ -1684,23 +1710,15 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 			auto const& argType = type(*arguments[i]);
 			if (auto literal = dynamic_cast<RationalNumberType const*>(argType.get()))
 			{
-				/* If no mobile type is available an error will be raised elsewhere. */
 				if (literal->mobileType())
+					m_errorReporter.typeError(
+						arguments[i]->location(),
+						"Cannot perform packed encoding for a literal. Please convert it to an explicit type first."
+					);
+				else
 				{
-					if (v050)
-						m_errorReporter.typeError(
-							arguments[i]->location(),
-							"Cannot perform packed encoding for a literal. Please convert it to an explicit type first."
-						);
-					else
-						m_errorReporter.warning(
-							arguments[i]->location(),
-							"The type of \"" +
-							argType->toString() +
-							"\" was inferred as " +
-							literal->mobileType()->toString() +
-							". This is probably not desired. Use an explicit type to silence this warning."
-						);
+					/* If no mobile type is available an error will be raised elsewhere. */
+					solAssert(m_errorReporter.hasErrors(), "");
 				}
 			}
 		}
@@ -1827,7 +1845,7 @@ bool TypeChecker::visit(FunctionCall const& _functionCall)
 		if (functionType->takesArbitraryParameters())
 			m_errorReporter.typeError(
 				_functionCall.location(),
-				"Named arguments cannnot be used for functions that take arbitrary parameters."
+				"Named arguments cannot be used for functions that take arbitrary parameters."
 			);
 		else if (parameterNames.size() > argumentNames.size())
 			m_errorReporter.typeError(_functionCall.location(), "Some argument names are missing.");
diff --git a/libsolidity/analysis/TypeChecker.h b/libsolidity/analysis/TypeChecker.h
index 2245abd6..8dc6b376 100644
--- a/libsolidity/analysis/TypeChecker.h
+++ b/libsolidity/analysis/TypeChecker.h
@@ -68,7 +68,7 @@ private:
 	void checkContractDuplicateFunctions(ContractDefinition const& _contract);
 	void checkContractDuplicateEvents(ContractDefinition const& _contract);
 	void checkContractIllegalOverrides(ContractDefinition const& _contract);
-	/// Reports a type error with an appropiate message if overriden function signature differs.
+	/// Reports a type error with an appropriate message if overridden function signature differs.
 	/// Also stores the direct super function in the AST annotations.
 	void checkFunctionOverride(FunctionDefinition const& function, FunctionDefinition const& super);
 	void overrideError(FunctionDefinition const& function, FunctionDefinition const& super, std::string message);