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

Added the using x for y directive.

Browse Source
This commit is contained in:
chriseth 2015-11-22 20:39:10 +01:00
parent 09b2f9acb7
commit d71cd3aa2b
10 changed files with 124 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libsolidity/analysis/NameAndTypeResolver.h
View File

@ -160,8 +160,8 @@ private:
void fatalDeclarationError(SourceLocation _sourceLocation, std::string const& _description);
std::map<ASTNode const*, DeclarationContainer>& m_scopes;
Declaration const* m_currentScope;
VariableScope* m_currentFunction;
Declaration const* m_currentScope = nullptr;
VariableScope* m_currentFunction = nullptr;
ErrorList& m_errors;
};

9
libsolidity/analysis/TypeChecker.cpp
View File

@ -359,6 +359,15 @@ void TypeChecker::endVisit(InheritanceSpecifier const& _inheritance)
);
}
void TypeChecker::endVisit(UsingForDirective const& _usingFor)
{
ContractDefinition const* library = dynamic_cast<ContractDefinition const*>(
_usingFor.libraryName().annotation().referencedDeclaration
);
if (!library || !library->isLibrary())
typeError(_usingFor.libraryName().location(), "Library name expected.");
}
bool TypeChecker::visit(StructDefinition const& _struct)
{
for (ASTPointer<VariableDeclaration> const& member: _struct.members())

1
libsolidity/analysis/TypeChecker.h
View File

@ -76,6 +76,7 @@ private:
void checkLibraryRequirements(ContractDefinition const& _contract);
virtual void endVisit(InheritanceSpecifier const& _inheritance) override;
virtual void endVisit(UsingForDirective const& _usingFor) override;
virtual bool visit(StructDefinition const& _struct) override;
virtual bool visit(FunctionDefinition const& _function) override;
virtual bool visit(VariableDeclaration const& _variable) override;

27
libsolidity/ast/AST.h
View File

@ -335,6 +335,33 @@ private:
std::vector<ASTPointer<Expression>> m_arguments;
};
/**
* `using LibraryName for uint` will attach all functions from the library LibraryName
* to `uint` if the first parameter matches the type. `using LibraryName for *` attaches
* the function to any matching type.
*/
class UsingForDirective: public ASTNode
{
public:
UsingForDirective(
SourceLocation const& _location,
ASTPointer<Identifier> const& _libraryName,
ASTPointer<TypeName> const& _typeName
):
ASTNode(_location), m_libraryName(_libraryName), m_typeName(_typeName) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
Identifier const& libraryName() const { return *m_libraryName; }
/// @returns the type name the library is attached to, null for `*`.
TypeName const* typeName() const { return m_typeName.get(); }
private:
ASTPointer<Identifier> m_libraryName;
ASTPointer<TypeName> m_typeName;
};
class StructDefinition: public Declaration
{
public:

4
libsolidity/ast/ASTVisitor.h
View File

@ -47,6 +47,7 @@ public:
virtual bool visit(ImportDirective& _node) { return visitNode(_node); }
virtual bool visit(ContractDefinition& _node) { return visitNode(_node); }
virtual bool visit(InheritanceSpecifier& _node) { return visitNode(_node); }
virtual bool visit(UsingForDirective& _node) { return visitNode(_node); }
virtual bool visit(StructDefinition& _node) { return visitNode(_node); }
virtual bool visit(EnumDefinition& _node) { return visitNode(_node); }
virtual bool visit(EnumValue& _node) { return visitNode(_node); }
@ -88,6 +89,7 @@ public:
virtual void endVisit(ImportDirective& _node) { endVisitNode(_node); }
virtual void endVisit(ContractDefinition& _node) { endVisitNode(_node); }
virtual void endVisit(InheritanceSpecifier& _node) { endVisitNode(_node); }
virtual void endVisit(UsingForDirective& _node) { endVisitNode(_node); }
virtual void endVisit(StructDefinition& _node) { endVisitNode(_node); }
virtual void endVisit(EnumDefinition& _node) { endVisitNode(_node); }
virtual void endVisit(EnumValue& _node) { endVisitNode(_node); }
@ -142,6 +144,7 @@ public:
virtual bool visit(ContractDefinition const& _node) { return visitNode(_node); }
virtual bool visit(InheritanceSpecifier const& _node) { return visitNode(_node); }
virtual bool visit(StructDefinition const& _node) { return visitNode(_node); }
virtual bool visit(UsingForDirective const& _node) { return visitNode(_node); }
virtual bool visit(EnumDefinition const& _node) { return visitNode(_node); }
virtual bool visit(EnumValue const& _node) { return visitNode(_node); }
virtual bool visit(ParameterList const& _node) { return visitNode(_node); }
@ -182,6 +185,7 @@ public:
virtual void endVisit(ImportDirective const& _node) { endVisitNode(_node); }
virtual void endVisit(ContractDefinition const& _node) { endVisitNode(_node); }
virtual void endVisit(InheritanceSpecifier const& _node) { endVisitNode(_node); }
virtual void endVisit(UsingForDirective const& _node) { endVisitNode(_node); }
virtual void endVisit(StructDefinition const& _node) { endVisitNode(_node); }
virtual void endVisit(EnumDefinition const& _node) { endVisitNode(_node); }
virtual void endVisit(EnumValue const& _node) { endVisitNode(_node); }

22
libsolidity/ast/AST_accept.h
View File

@ -123,6 +123,28 @@ void EnumValue::accept(ASTConstVisitor& _visitor) const
_visitor.endVisit(*this);
}
void UsingForDirective::accept(ASTVisitor& _visitor)
{
if (_visitor.visit(*this))
{
if (m_libraryName)
m_libraryName->accept(_visitor);
m_typeName->accept(_visitor);
}
_visitor.endVisit(*this);
}
void UsingForDirective::accept(ASTConstVisitor& _visitor) const
{
if (_visitor.visit(*this))
{
if (m_libraryName)
m_libraryName->accept(_visitor);
m_typeName->accept(_visitor);
}
_visitor.endVisit(*this);
}
void StructDefinition::accept(ASTVisitor& _visitor)
{
if (_visitor.visit(*this))

20
libsolidity/parsing/Parser.cpp
View File

@ -168,6 +168,8 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition(bool _isLibrary)
subNodes.push_back(parseModifierDefinition());
else if (currentTokenValue == Token::Event)
subNodes.push_back(parseEventDefinition());
else if (currentTokenValue == Token::Using)
subNodes.push_back(parseUsingDirective());
else
fatalParserError(std::string("Function, variable, struct or modifier declaration expected."));
}
@ -475,6 +477,24 @@ ASTPointer<EventDefinition> Parser::parseEventDefinition()
return nodeFactory.createNode<EventDefinition>(name, docstring, parameters, anonymous);
}
ASTPointer<UsingForDirective> Parser::parseUsingDirective()
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Using);
//@todo this should actually parse a full path.
ASTPointer<Identifier> library(parseIdentifier());
ASTPointer<TypeName> typeName;
expectToken(Token::For);
if (m_scanner->currentToken() == Token::Mul)
m_scanner->next();
else
typeName = parseTypeName(false);
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<UsingForDirective>(library, typeName);
}
ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
{
ASTNodeFactory nodeFactory(*this);

1
libsolidity/parsing/Parser.h
View File

@ -74,6 +74,7 @@ private:
);
ASTPointer<ModifierDefinition> parseModifierDefinition();
ASTPointer<EventDefinition> parseEventDefinition();
ASTPointer<UsingForDirective> parseUsingDirective();
ASTPointer<ModifierInvocation> parseModifierInvocation();
ASTPointer<Identifier> parseIdentifier();
ASTPointer<TypeName> parseTypeName(bool _allowVar);

22
test/libsolidity/SolidityNameAndTypeResolution.cpp
View File

@ -2529,6 +2529,28 @@ BOOST_AUTO_TEST_CASE(member_access_parser_ambiguity)
BOOST_CHECK(success(text));
}
BOOST_AUTO_TEST_CASE(using_for_library)
{
char const* text = R"(
library D { }
contract C {
using D for uint;
}
)";
BOOST_CHECK(success(text));
}
BOOST_AUTO_TEST_CASE(using_for_not_library)
{
char const* text = R"(
contract D { }
contract C {
using D for uint;
}
)";
BOOST_CHECK(expectError(text) == Error::Type::TypeError);
}
BOOST_AUTO_TEST_CASE(create_memory_arrays)
{
char const* text = R"(

15
test/libsolidity/SolidityParser.cpp
View File

@ -1032,6 +1032,21 @@ BOOST_AUTO_TEST_CASE(member_access_parser_ambiguity)
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_CASE(using_for)
{
char const* text = R"(
contract C {
struct s { uint a; }
using LibraryName for uint;
using Library2 for *;
using Lib for s;
function f() {
}
}
)";
BOOST_CHECK(successParse(text));
}
BOOST_AUTO_TEST_SUITE_END()
}