aboutsummaryrefslogtreecommitdiffstats
path: root/libsolidity
diff options
context:
space:
mode:
Diffstat (limited to 'libsolidity')
-rw-r--r--libsolidity/analysis/NameAndTypeResolver.cpp25
-rw-r--r--libsolidity/analysis/NameAndTypeResolver.h8
-rw-r--r--libsolidity/ast/AST.cpp13
-rw-r--r--libsolidity/ast/AST.h79
-rw-r--r--libsolidity/ast/ASTAnnotations.h10
-rw-r--r--libsolidity/ast/Types.cpp20
-rw-r--r--libsolidity/ast/Types.h32
-rw-r--r--libsolidity/interface/CompilerStack.cpp3
-rw-r--r--libsolidity/parsing/Parser.cpp2
9 files changed, 140 insertions, 52 deletions
diff --git a/libsolidity/analysis/NameAndTypeResolver.cpp b/libsolidity/analysis/NameAndTypeResolver.cpp
index 02e4d7ab..92347bfc 100644
--- a/libsolidity/analysis/NameAndTypeResolver.cpp
+++ b/libsolidity/analysis/NameAndTypeResolver.cpp
@@ -46,14 +46,16 @@ NameAndTypeResolver::NameAndTypeResolver(
bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit)
{
- solAssert(!m_scopes[&_sourceUnit], "");
- m_scopes[&_sourceUnit].reset(new DeclarationContainer(nullptr, m_scopes[nullptr].get()));
+ if (!m_scopes[&_sourceUnit])
+ // By importing, it is possible that the container already exists.
+ m_scopes[&_sourceUnit].reset(new DeclarationContainer(nullptr, m_scopes[nullptr].get()));
m_currentScope = m_scopes[&_sourceUnit].get();
// The helper registers all declarations in m_scopes as a side-effect of its construction.
try
{
DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errors);
+ _sourceUnit.annotation().exportedSymbols = m_scopes[&_sourceUnit]->declarations();
}
catch (FatalError const&)
{
@@ -83,7 +85,7 @@ bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, So
);
error = true;
}
- else
+ else if (imp->name().empty())
{
auto scope = m_scopes.find(_sourceUnits.at(path));
solAssert(scope != end(m_scopes), "");
@@ -380,7 +382,7 @@ void NameAndTypeResolver::reportFatalTypeError(Error const& _e)
}
DeclarationRegistrationHelper::DeclarationRegistrationHelper(
- map<ASTNode const*, unique_ptr<DeclarationContainer>>& _scopes,
+ map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
ASTNode& _astRoot,
ErrorList& _errors
):
@@ -392,6 +394,17 @@ DeclarationRegistrationHelper::DeclarationRegistrationHelper(
_astRoot.accept(*this);
}
+bool DeclarationRegistrationHelper::visit(ImportDirective& _import)
+{
+ SourceUnit const* importee = _import.annotation().sourceUnit;
+ solAssert(!!importee, "");
+ if (!m_scopes[importee])
+ m_scopes[importee].reset(new DeclarationContainer(nullptr, m_scopes[nullptr].get()));
+ m_scopes[&_import] = m_scopes[importee];
+ registerDeclaration(_import, false);
+ return true;
+}
+
bool DeclarationRegistrationHelper::visit(ContractDefinition& _contract)
{
registerDeclaration(_contract, true);
@@ -489,9 +502,9 @@ void DeclarationRegistrationHelper::endVisit(EventDefinition&)
void DeclarationRegistrationHelper::enterNewSubScope(Declaration const& _declaration)
{
- map<ASTNode const*, unique_ptr<DeclarationContainer>>::iterator iter;
+ map<ASTNode const*, shared_ptr<DeclarationContainer>>::iterator iter;
bool newlyAdded;
- unique_ptr<DeclarationContainer> container(new DeclarationContainer(m_currentScope, m_scopes[m_currentScope].get()));
+ shared_ptr<DeclarationContainer> container(new DeclarationContainer(m_currentScope, m_scopes[m_currentScope].get()));
tie(iter, newlyAdded) = m_scopes.emplace(&_declaration, move(container));
solAssert(newlyAdded, "Unable to add new scope.");
m_currentScope = &_declaration;
diff --git a/libsolidity/analysis/NameAndTypeResolver.h b/libsolidity/analysis/NameAndTypeResolver.h
index 3c444aba..89b9818b 100644
--- a/libsolidity/analysis/NameAndTypeResolver.h
+++ b/libsolidity/analysis/NameAndTypeResolver.h
@@ -111,7 +111,8 @@ private:
/// Maps nodes declaring a scope to scopes, i.e. ContractDefinition and FunctionDeclaration,
/// where nullptr denotes the global scope. Note that structs are not scope since they do
/// not contain code.
- std::map<ASTNode const*, std::unique_ptr<DeclarationContainer>> m_scopes;
+ /// Aliases (for example `import "x" as y;`) create multiple pointers to the same scope.
+ std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>> m_scopes;
DeclarationContainer* m_currentScope = nullptr;
ErrorList& m_errors;
@@ -125,12 +126,13 @@ class DeclarationRegistrationHelper: private ASTVisitor
{
public:
DeclarationRegistrationHelper(
- std::map<ASTNode const*, std::unique_ptr<DeclarationContainer>>& _scopes,
+ std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& _scopes,
ASTNode& _astRoot,
ErrorList& _errors
);
private:
+ bool visit(ImportDirective& _declaration) override;
bool visit(ContractDefinition& _contract) override;
void endVisit(ContractDefinition& _contract) override;
bool visit(StructDefinition& _struct) override;
@@ -166,7 +168,7 @@ private:
// creates the Declaration error and adds it in the errors list and throws FatalError
void fatalDeclarationError(SourceLocation _sourceLocation, std::string const& _description);
- std::map<ASTNode const*, std::unique_ptr<DeclarationContainer>>& m_scopes;
+ std::map<ASTNode const*, std::shared_ptr<DeclarationContainer>>& m_scopes;
ASTNode const* m_currentScope = nullptr;
VariableScope* m_currentFunction = nullptr;
ErrorList& m_errors;
diff --git a/libsolidity/ast/AST.cpp b/libsolidity/ast/AST.cpp
index 701202f9..b5affa8e 100644
--- a/libsolidity/ast/AST.cpp
+++ b/libsolidity/ast/AST.cpp
@@ -56,6 +56,13 @@ Error ASTNode::createTypeError(string const& _description) const
return Error(Error::Type::TypeError) << errinfo_sourceLocation(location()) << errinfo_comment(_description);
}
+SourceUnitAnnotation& SourceUnit::annotation() const
+{
+ if (!m_annotation)
+ m_annotation = new SourceUnitAnnotation();
+ return static_cast<SourceUnitAnnotation&>(*m_annotation);
+}
+
ImportAnnotation& ImportDirective::annotation() const
{
if (!m_annotation)
@@ -63,6 +70,12 @@ ImportAnnotation& ImportDirective::annotation() const
return static_cast<ImportAnnotation&>(*m_annotation);
}
+TypePointer ImportDirective::type() const
+{
+ solAssert(!!annotation().sourceUnit, "");
+ return make_shared<ModuleType>(*annotation().sourceUnit);
+}
+
map<FixedHash<4>, FunctionTypePointer> ContractDefinition::interfaceFunctions() const
{
auto exportedFunctionList = interfaceFunctionList();
diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h
index e270afd5..84e9e706 100644
--- a/libsolidity/ast/AST.h
+++ b/libsolidity/ast/AST.h
@@ -120,6 +120,7 @@ public:
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
+ virtual SourceUnitAnnotation& annotation() const override;
std::vector<ASTPointer<ASTNode>> nodes() const { return m_nodes; }
@@ -128,44 +129,7 @@ private:
};
/**
- * Import directive for referencing other files / source objects.
- * Example: import "abc.sol" // imports all symbols of "abc.sol" into current scope
- * Source objects are identified by a string which can be a file name but does not have to be.
- * Other ways to use it:
- * import "abc" as x; // creates symbol "x" that contains all symbols in "abc"
- * import * as x from "abc"; // same as above
- * import {a as b, c} from "abc"; // creates new symbols "b" and "c" referencing "a" and "c" in "abc", respectively.
- */
-class ImportDirective: public ASTNode
-{
-public:
- ImportDirective(
- SourceLocation const& _location,
- ASTPointer<ASTString> const& _path,
- ASTPointer<ASTString> const& _unitAlias,
- std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>>&& _symbolAliases
- ):
- ASTNode(_location), m_path(_path), m_unitAlias(_unitAlias), m_symbolAliases(_symbolAliases) {}
-
- virtual void accept(ASTVisitor& _visitor) override;
- virtual void accept(ASTConstVisitor& _visitor) const override;
-
- ASTString const& path() const { return *m_path; }
- virtual ImportAnnotation& annotation() const override;
-
-private:
- ASTPointer<ASTString> m_path;
- /// The alias for the module itself. If present, import the whole unit under that name and
- /// ignore m_symbolAlias.
- ASTPointer<ASTString> m_unitAlias;
- /// The aliases for the specific symbols to import. If non-empty import the specific symbols.
- /// If the second component is empty, import the identifier unchanged.
- /// If both m_unitAlias and m_symbolAlias are empty, import all symbols into the current scope.
- std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>> m_symbolAliases;
-};
-
-/**
- * Abstract AST class for a declaration (contract, function, struct, variable).
+ * Abstract AST class for a declaration (contract, function, struct, variable, import directive).
*/
class Declaration: public ASTNode
{
@@ -211,6 +175,45 @@ private:
};
/**
+ * Import directive for referencing other files / source objects.
+ * Example: import "abc.sol" // imports all symbols of "abc.sol" into current scope
+ * Source objects are identified by a string which can be a file name but does not have to be.
+ * Other ways to use it:
+ * import "abc" as x; // creates symbol "x" that contains all symbols in "abc"
+ * import * as x from "abc"; // same as above
+ * import {a as b, c} from "abc"; // creates new symbols "b" and "c" referencing "a" and "c" in "abc", respectively.
+ */
+class ImportDirective: public Declaration
+{
+public:
+ ImportDirective(
+ SourceLocation const& _location,
+ ASTPointer<ASTString> const& _path,
+ ASTPointer<ASTString> const& _unitAlias,
+ std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>>&& _symbolAliases
+ ):
+ Declaration(_location, _unitAlias),
+ m_path(_path),
+ m_symbolAliases(_symbolAliases)
+ { }
+
+ virtual void accept(ASTVisitor& _visitor) override;
+ virtual void accept(ASTConstVisitor& _visitor) const override;
+
+ ASTString const& path() const { return *m_path; }
+ virtual ImportAnnotation& annotation() const override;
+
+ virtual TypePointer type() const override;
+
+private:
+ ASTPointer<ASTString> m_path;
+ /// The aliases for the specific symbols to import. If non-empty import the specific symbols.
+ /// If the second component is empty, import the identifier unchanged.
+ /// If both m_unitAlias and m_symbolAlias are empty, import all symbols into the current scope.
+ std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>> m_symbolAliases;
+};
+
+/**
* Abstract class that is added to each AST node that can store local variables.
*/
class VariableScope
diff --git a/libsolidity/ast/ASTAnnotations.h b/libsolidity/ast/ASTAnnotations.h
index 0bc91c60..235338bb 100644
--- a/libsolidity/ast/ASTAnnotations.h
+++ b/libsolidity/ast/ASTAnnotations.h
@@ -54,10 +54,20 @@ struct DocumentedAnnotation
std::multimap<std::string, DocTag> docTags;
};
+struct SourceUnitAnnotation: ASTAnnotation
+{
+ /// The "absolute" (in the compiler sense) path of this source unit.
+ std::string path;
+ /// The exported symbols (all global symbols).
+ std::map<ASTString, std::vector<Declaration const*>> exportedSymbols;
+};
+
struct ImportAnnotation: ASTAnnotation
{
/// The absolute path of the source unit to import.
std::string absolutePath;
+ /// The actual source unit.
+ SourceUnit const* sourceUnit = nullptr;
};
struct TypeDeclarationAnnotation: ASTAnnotation
diff --git a/libsolidity/ast/Types.cpp b/libsolidity/ast/Types.cpp
index 2dc7fb84..49347022 100644
--- a/libsolidity/ast/Types.cpp
+++ b/libsolidity/ast/Types.cpp
@@ -1925,9 +1925,25 @@ string ModifierType::toString(bool _short) const
return name + ")";
}
-MagicType::MagicType(MagicType::Kind _kind):
- m_kind(_kind)
+bool ModuleType::operator==(Type const& _other) const
{
+ if (_other.category() != category())
+ return false;
+ return &m_sourceUnit == &dynamic_cast<ModuleType const&>(_other).m_sourceUnit;
+}
+
+MemberList::MemberMap ModuleType::nativeMembers(ContractDefinition const*) const
+{
+ MemberList::MemberMap symbols;
+ for (auto const& symbolName: m_sourceUnit.annotation().exportedSymbols)
+ for (Declaration const* symbol: symbolName.second)
+ symbols.push_back(MemberList::Member(symbolName.first, symbol->type(), symbol));
+ return symbols;
+}
+
+string ModuleType::toString(bool) const
+{
+ return string("module \"") + m_sourceUnit.annotation().path + string("\"");
}
bool MagicType::operator==(Type const& _other) const
diff --git a/libsolidity/ast/Types.h b/libsolidity/ast/Types.h
index 3ebcb2b2..723d633b 100644
--- a/libsolidity/ast/Types.h
+++ b/libsolidity/ast/Types.h
@@ -134,7 +134,7 @@ public:
{
Integer, IntegerConstant, StringLiteral, Bool, Real, Array,
FixedBytes, Contract, Struct, Function, Enum, Tuple,
- Mapping, TypeType, Modifier, Magic
+ Mapping, TypeType, Modifier, Magic, Module
};
/// @{
@@ -969,6 +969,34 @@ private:
};
+
+/**
+ * Special type for imported modules. These mainly give access to their scope via members.
+ */
+class ModuleType: public Type
+{
+public:
+ virtual Category category() const override { return Category::Module; }
+
+ explicit ModuleType(SourceUnit const& _source): m_sourceUnit(_source) {}
+
+ virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override
+ {
+ return TypePointer();
+ }
+
+ virtual bool operator==(Type const& _other) const override;
+ virtual bool canBeStored() const override { return false; }
+ virtual bool canLiveOutsideStorage() const override { return true; }
+ virtual unsigned sizeOnStack() const override { return 0; }
+ virtual MemberList::MemberMap nativeMembers(ContractDefinition const*) const override;
+
+ virtual std::string toString(bool _short) const override;
+
+private:
+ SourceUnit const& m_sourceUnit;
+};
+
/**
* Special type for magic variables (block, msg, tx), similar to a struct but without any reference
* (it always references a global singleton by name).
@@ -979,7 +1007,7 @@ public:
enum class Kind { Block, Message, Transaction };
virtual Category category() const override { return Category::Magic; }
- explicit MagicType(Kind _kind);
+ explicit MagicType(Kind _kind): m_kind(_kind) {}
virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override
{
diff --git a/libsolidity/interface/CompilerStack.cpp b/libsolidity/interface/CompilerStack.cpp
index 3238423a..a6f6f224 100644
--- a/libsolidity/interface/CompilerStack.cpp
+++ b/libsolidity/interface/CompilerStack.cpp
@@ -111,6 +111,8 @@ bool CompilerStack::parse()
sourcePair.second.ast = Parser(m_errors).parse(sourcePair.second.scanner);
if (!sourcePair.second.ast)
solAssert(!Error::containsOnlyWarnings(m_errors), "Parser returned null but did not report error.");
+ else
+ sourcePair.second.ast->annotation().path = sourcePair.first;
sourceUnitsByName[sourcePair.first] = sourcePair.second.ast.get();
}
if (!Error::containsOnlyWarnings(m_errors))
@@ -384,6 +386,7 @@ void CompilerStack::resolveImports()
<< errinfo_sourceLocation(import->location())
<< errinfo_comment("Source not found.")
);
+ import->annotation().sourceUnit = m_sources.at(path).ast.get();
toposort(path, &m_sources[path]);
}
diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp
index 2b856930..2b31c385 100644
--- a/libsolidity/parsing/Parser.cpp
+++ b/libsolidity/parsing/Parser.cpp
@@ -119,7 +119,7 @@ ASTPointer<ImportDirective> Parser::parseImportDirective()
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Import);
ASTPointer<ASTString> path;
- ASTPointer<ASTString> unitAlias;
+ ASTPointer<ASTString> unitAlias = make_shared<string>();
vector<pair<ASTPointer<Identifier>, ASTPointer<ASTString>>> symbolAliases;
if (m_scanner->currentToken() == Token::StringLiteral)
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 23:05:42 +0800