Merge pull request #2532 from ethereum/develop

Merge develop to release for 0.4.13.

Author: chriseth

.travis.yml

@@ -221,6 +221,7 @@ deploy:
           branch:
             - develop
             - release
+            - /^v[0-9]/
     # This is the deploy target for the native build (Linux and macOS)
     # which generates ZIPs per commit and the source tarball.
     #

CMakeLists.txt

@@ -8,7 +8,7 @@ include(EthPolicy)
 eth_policy()
 
 # project name and version should be set after cmake_policy CMP0048
-set(PROJECT_VERSION "0.4.12")
+set(PROJECT_VERSION "0.4.13")
 project(solidity VERSION ${PROJECT_VERSION})
 
 # Let's find our dependencies

Changelog.md

@@ -1,3 +1,14 @@
+### 0.4.13 (2017-07-06)
+
+Features:
+ * Syntax Checker: Deprecated "throw" in favour of require(), assert() and revert().
+ * Type Checker: Warn if a local storage reference variable does not explicitly use the keyword ``storage``.
+
+Bugfixes:
+ * Code Generator: Correctly unregister modifier variables.
+ * Compiler Interface: Only output AST if analysis was successful.
+ * Error Output: Do not omit the error type.
+
 ### 0.4.12 (2017-07-03)
 
 Features:

docs/bugs_by_version.json

@@ -301,6 +301,10 @@
         "bugs": [], 
         "released": "2017-07-03"
     }, 
+    "0.4.13": {
+        "bugs": [], 
+        "released": "2017-07-06"
+    }, 
     "0.4.2": {
         "bugs": [
             "SkipEmptyStringLiteral", 

docs/contributing.rst

@@ -78,10 +78,10 @@ Alternatively, there is a testing script at ``scripts/test.sh`` which executes a
 Whiskers
 ========
 
-*Whiskers* is a templating system similar to `Moustache <https://mustache.github.io>`_. It is used by the
+*Whiskers* is a templating system similar to `Mustache <https://mustache.github.io>`_. It is used by the
 compiler in various places to aid readability, and thus maintainability and verifiability, of the code.
 
-The syntax comes with a substantial difference to Moustache: the template markers ``{{`` and ``}}`` are
+The syntax comes with a substantial difference to Mustache: the template markers ``{{`` and ``}}`` are
 replaced by ``<`` and ``>`` in order to aid parsing and avoid conflicts with :ref:`inline-assembly`
 (The symbols ``<`` and ``>`` are invalid in inline assembly, while ``{`` and ``}`` are used to delimit blocks).
 Another limitation is that lists are only resolved one depth and they will not recurse. This may change in the future.
@@ -91,5 +91,5 @@ A rough specification is the following:
 Any occurrence of ``<name>`` is replaced by the string-value of the supplied variable ``name`` without any
 escaping and without iterated replacements. An area can be delimited by ``<#name>...</name>``. It is replaced
 by as many concatenations of its contents as there were sets of variables supplied to the template system,
-each time replacing any ``<inner>`` items by their respective value. Top-level variales can also be used
-inside such areas.
+each time replacing any ``<inner>`` items by their respective value. Top-level variables can also be used
+inside such areas.

libsolidity/analysis/ReferencesResolver.cpp

@@ -289,7 +289,20 @@ void ReferencesResolver::endVisit(VariableDeclaration const& _variable)
 					typeLoc = DataLocation::Memory;
 				}
 				else if (varLoc == Location::Default)
-					typeLoc = _variable.isCallableParameter() ? DataLocation::Memory : DataLocation::Storage;
+				{
+					if (_variable.isCallableParameter())
+						typeLoc = DataLocation::Memory;
+					else
+					{
+						typeLoc = DataLocation::Storage;
+						if (!_variable.isStateVariable())
+							m_errorReporter.warning(
+								_variable.location(),
+								"Variable is declared as a storage pointer. "
+								"Use an explicit \"storage\" keyword to silence this warning."
+							);
+					}
+				}
 				else
 					typeLoc = varLoc == Location::Memory ? DataLocation::Memory : DataLocation::Storage;
 				isPointer = !_variable.isStateVariable();

libsolidity/analysis/SyntaxChecker.cpp

@@ -135,6 +135,16 @@ bool SyntaxChecker::visit(Break const& _breakStatement)
 	return true;
 }
 
+bool SyntaxChecker::visit(Throw const& _throwStatement)
+{
+	m_errorReporter.warning(
+		_throwStatement.location(),
+		"\"throw\" is deprecated in favour of \"revert()\", \"require()\" and \"assert()\"."
+	);
+
+	return true;
+}
+
 bool SyntaxChecker::visit(UnaryOperation const& _operation)
 {
 	if (_operation.getOperator() == Token::Add)

libsolidity/analysis/SyntaxChecker.h

@@ -33,6 +33,7 @@ namespace solidity
  *  - whether continue/break is in a for/while loop.
  *  - whether a modifier contains at least one '_'
  *  - issues deprecation warnings for unary '+'
+ *  - issues deprecation warning for throw
  */
 class SyntaxChecker: private ASTConstVisitor
 {
@@ -59,6 +60,8 @@ class SyntaxChecker: private ASTConstVisitor
 	virtual bool visit(Continue const& _continueStatement) override;
 	virtual bool visit(Break const& _breakStatement) override;
 
+	virtual bool visit(Throw const& _throwStatement) override;
+
 	virtual bool visit(UnaryOperation const& _operation) override;
 
 	virtual bool visit(PlaceholderStatement const& _placeholderStatement) override;

libsolidity/analysis/TypeChecker.cpp

@@ -854,10 +854,12 @@ bool TypeChecker::visit(VariableDeclarationStatement const& _statement)
 		if (auto ref = dynamic_cast<ReferenceType const*>(type(varDecl).get()))
 		{
 			if (ref->dataStoredIn(DataLocation::Storage))
-				m_errorReporter.warning(
-					varDecl.location(),
-					"Uninitialized storage pointer. Did you mean '<type> memory " + varDecl.name() + "'?"
-				);
+			{
+				string errorText{"Uninitialized storage pointer."};
+				if (varDecl.referenceLocation() == VariableDeclaration::Location::Default)
+					errorText += " Did you mean '<type> memory " + varDecl.name() + "'?";
+				m_errorReporter.warning(varDecl.location(), errorText);
+			}
 		}
 		else if (dynamic_cast<MappingType const*>(type(varDecl).get()))
 			m_errorReporter.typeError(

libsolidity/codegen/ContractCompiler.cpp

@@ -928,7 +928,10 @@ void ContractCompiler::appendModifierOrFunctionCode()
 				);
 			}
 			for (VariableDeclaration const* localVariable: modifier.localVariables())
+			{
+				addedVariables.push_back(localVariable);
 				appendStackVariableInitialisation(*localVariable);
+			}
 
 			stackSurplus =
 				CompilerUtils::sizeOnStack(modifier.parameters()) +