Support experimental feature pragma

libsolidity/analysis/SyntaxChecker.cpp

@@ -18,6 +18,7 @@
 #include <libsolidity/analysis/SyntaxChecker.h>
 #include <memory>
 #include <libsolidity/ast/AST.h>
+#include <libsolidity/ast/ExperimentalFeatures.h>
 #include <libsolidity/analysis/SemVerHandler.h>
 #include <libsolidity/interface/ErrorReporter.h>
 #include <libsolidity/interface/Version.h>
@@ -33,9 +34,10 @@ bool SyntaxChecker::checkSyntax(ASTNode const& _astRoot)
 	return Error::containsOnlyWarnings(m_errorReporter.errors());
 }
 
-bool SyntaxChecker::visit(SourceUnit const&)
+bool SyntaxChecker::visit(SourceUnit const& _sourceUnit)
 {
 	m_versionPragmaFound = false;
+	m_sourceUnit = &_sourceUnit;
 	return true;
 }
 
@@ -57,15 +59,46 @@ void SyntaxChecker::endVisit(SourceUnit const& _sourceUnit)
 
 		m_errorReporter.warning(_sourceUnit.location(), errorString);
 	}
+	m_sourceUnit = nullptr;
 }
 
 bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 {
 	solAssert(!_pragma.tokens().empty(), "");
 	solAssert(_pragma.tokens().size() == _pragma.literals().size(), "");
-	if (_pragma.tokens()[0] != Token::Identifier || _pragma.literals()[0] != "solidity")
-		m_errorReporter.syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\"");
-	else
+	if (_pragma.tokens()[0] != Token::Identifier)
+		m_errorReporter.syntaxError(_pragma.location(), "Invalid pragma \"" + _pragma.literals()[0] + "\"");
+	else if (_pragma.literals()[0] == "experimental")
+	{
+		solAssert(m_sourceUnit, "");
+		vector<string> literals(_pragma.literals().begin() + 1, _pragma.literals().end());
+		if (literals.size() == 0)
+			m_errorReporter.syntaxError(
+				_pragma.location(),
+				"Experimental feature name is missing."
+			);
+		else if (literals.size() > 1)
+			m_errorReporter.syntaxError(
+				_pragma.location(),
+				"Stray arguments."
+			);
+		else
+		{
+			string const literal = literals[0];
+			if (literal.empty())
+				m_errorReporter.syntaxError(_pragma.location(), "Empty experimental feature name is invalid.");
+			else if (!ExperimentalFeatureNames.count(literal))
+				m_errorReporter.syntaxError(_pragma.location(), "Unsupported experimental feature name.");
+			else if (m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeatureNames.at(literal)))
+				m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name.");
+			else
+			{
+				m_sourceUnit->annotation().experimentalFeatures.insert(ExperimentalFeatureNames.at(literal));
+				m_errorReporter.warning(_pragma.location(), "Experimental features are turned on. Do not use experimental features on live deployments.");
+			}
+		}
+	}
+	else if (_pragma.literals()[0] == "solidity")
 	{
 		vector<Token::Value> tokens(_pragma.tokens().begin() + 1, _pragma.tokens().end());
 		vector<string> literals(_pragma.literals().begin() + 1, _pragma.literals().end());
@@ -81,6 +114,8 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma)
 			);
 		m_versionPragmaFound = true;
 	}
+	else
+		m_errorReporter.syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\"");
 	return true;
 }
 

libsolidity/analysis/SyntaxChecker.h

@@ -77,6 +77,8 @@ class SyntaxChecker: private ASTConstVisitor
 	bool m_versionPragmaFound = false;
 
 	int m_inLoopDepth = 0;
+
+	SourceUnit const* m_sourceUnit = nullptr;
 };
 
 }

libsolidity/ast/ASTAnnotations.h

@@ -23,6 +23,7 @@
 #pragma once
 
 #include <libsolidity/ast/ASTForward.h>
+#include <libsolidity/ast/ExperimentalFeatures.h>
 
 #include <map>
 #include <memory>
@@ -61,6 +62,8 @@ struct SourceUnitAnnotation: ASTAnnotation
 	std::string path;
 	/// The exported symbols (all global symbols).
 	std::map<ASTString, std::vector<Declaration const*>> exportedSymbols;
+	/// Experimental features.
+	std::set<ExperimentalFeature> experimentalFeatures;
 };
 
 struct ImportAnnotation: ASTAnnotation

libsolidity/ast/ExperimentalFeatures.h

@@ -0,0 +1,35 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * List of experimental features.
+ */
+
+#pragma once
+
+#include <map>
+
+namespace dev
+{
+namespace solidity
+{
+
+enum class ExperimentalFeature {};
+
+static const std::map<std::string, ExperimentalFeature> ExperimentalFeatureNames = {};
+
+}
+}

test/libsolidity/SolidityNameAndTypeResolution.cpp

@@ -6558,6 +6558,43 @@ BOOST_AUTO_TEST_CASE(library_function_without_implementation)
 	CHECK_ERROR(text, TypeError, "Internal library function must be implemented if declared.");
 }
 
+BOOST_AUTO_TEST_CASE(experimental_pragma)
+{
+	char const* text = R"(
+		pragma experimental;
+	)";
+	CHECK_ERROR(text, SyntaxError, "Experimental feature name is missing.");
+	text = R"(
+		pragma experimental 123;
+	)";
+	CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name.");
+	text = R"(
+		pragma experimental unsupportedName;
+	)";
+	CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name.");
+	text = R"(
+		pragma experimental "unsupportedName";
+	)";
+	CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name.");
+	text = R"(
+		pragma experimental "";
+	)";
+	CHECK_ERROR(text, SyntaxError, "Empty experimental feature name is invalid.");
+	text = R"(
+		pragma experimental unsupportedName unsupportedName;
+	)";
+	CHECK_ERROR(text, SyntaxError, "Stray arguments.");
+//	text = R"(
+//		pragma experimental supportedName;
+//	)";
+//	CHECK_WARNING(text, "Experimental features are turned on. Do not use experimental features on live deployments.");
+//	text = R"(
+//		pragma experimental supportedName;
+//		pragma experimental supportedName;
+//	)";
+//	CHECK_ERROR(text, SyntaxError, "Duplicate experimental feature name.");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }