Rework typeViaContractName and nativeMembers fragment.

Author: rodiazet

libsolidity/analysis/TypeChecker.cpp

@@ -4054,7 +4054,7 @@ void TypeChecker::endVisit(UsingForDirective const& _usingFor)
 
 		FunctionType const* functionType = dynamic_cast<FunctionType const*>(
 			functionDefinition.libraryFunction() ?
-				functionDefinition.typeViaContractName() :
+				functionDefinition.typeViaContractName(Declaration::ContractNameAccessKind::Library) :
 				functionDefinition.type()
 			);
 

libsolidity/ast/AST.cpp

@@ -491,17 +491,47 @@ Type const* FunctionDefinition::type() const
 	return TypeProvider::function(*this, FunctionType::Kind::Internal);
 }
 
-Type const* FunctionDefinition::typeViaContractName() const
+Type const* FunctionDefinition::typeViaContractName(ContractNameAccessKind _accessKind) const
 {
-	if (libraryFunction())
+	switch (_accessKind)
 	{
-		if (isPublic())
-			return FunctionType(*this).asExternallyCallableFunction(true);
-		else
-			return TypeProvider::function(*this, FunctionType::Kind::Internal);
+		case ContractNameAccessKind::Local:
+		{
+			solAssert(!libraryFunction(), "Library member cannot be accessed from local/deriving scope");
+			solAssert(visibility() > Visibility::Private, "Private non-library member is not visible via contract type name");
+
+			if (!Declaration::isVisibleInContract() || !isImplemented())
+				// If is external or has no implementation, it cannot be called using contract type name. In case of accessing
+				// via contract type name, only declaration is available, to be used in non calling context. I.e. to access
+				// function selector `C.foo.selector` where foo has external visibility.
+				return TypeProvider::function(*this, FunctionType::Kind::Declaration);
+			else
+				// If call is in local (or deriving) scope, function is visible in contract (non-external) and it has an
+				// implementation, internal call is used.
+				return type();
+		}
+		case ContractNameAccessKind::Foreign:
+		{
+			solAssert(!libraryFunction(), "Library members can only be accessed via library name.");
+			solAssert(isVisibleViaContractInstance(), "Externally invisible member accessed via contract name.");
+			// Foreign contract member function being accessed via contract type name, cannot be called.
+			return TypeProvider::function(*this, FunctionType::Kind::Declaration);
+		}
+		case ContractNameAccessKind::Library:
+		{
+			// Private library members can be accessed in context of `using` statement.
+			solAssert(libraryFunction(), "Non-library members cannot be accessed via library name.");
+			// In case of library contract, member call kind depends on its visibility.
+			if (isPublic())
+				// When Lib.foo is public or external, an external call (delegate call) is used.
+				return FunctionType(*this).asExternallyCallableFunction(true);
+			else
+				// For private or internal visibility, internal call is used.
+				return type();
+		}
+		default:
+			solAssert(false, "Unimplemented contract member access kind.");
 	}
-	else
-		return TypeProvider::function(*this, FunctionType::Kind::Declaration);
 }
 
 std::string FunctionDefinition::externalSignature() const
@@ -952,7 +982,7 @@ FunctionType const* UnaryOperation::userDefinedFunctionType() const
 	FunctionDefinition const* userDefinedFunction = *annotation().userDefinedFunction;
 	return dynamic_cast<FunctionType const*>(
 		userDefinedFunction->libraryFunction() ?
-		userDefinedFunction->typeViaContractName() :
+		userDefinedFunction->typeViaContractName(Declaration::ContractNameAccessKind::Library) :
 		userDefinedFunction->type()
 	);
 }
@@ -965,7 +995,7 @@ FunctionType const* BinaryOperation::userDefinedFunctionType() const
 	FunctionDefinition const* userDefinedFunction = *annotation().userDefinedFunction;
 	return dynamic_cast<FunctionType const*>(
 		userDefinedFunction->libraryFunction() ?
-		userDefinedFunction->typeViaContractName() :
+		userDefinedFunction->typeViaContractName(Declaration::ContractNameAccessKind::Library) :
 		userDefinedFunction->type()
 	);
 }

libsolidity/ast/AST.h

@@ -297,9 +297,16 @@ class Declaration: public ASTNode, public Scopable
 	/// This can only be called once types of variable declarations have already been resolved.
 	virtual Type const* type() const = 0;
 
-	/// @returns the type for members of the containing contract type that refer to this declaration.
+	/// Defines type of member access via contract type name.
+	/// @Local means access via contract name from local contract scope or deriving contract.
+	/// @Foreign means access via contract name from foreign (unrelated) contract.
+	/// @Library means access via library name.
+	enum class ContractNameAccessKind { Local, Foreign, Library };
+
+	/// @returns the type for members of the containing contract type that refer to this declaration. Depends on access
+	/// context defined by `ContractNameAccessKind`.
 	/// This can only be called once types of variable declarations have already been resolved.
-	virtual Type const* typeViaContractName() const { return type(); }
+	virtual Type const* typeViaContractName(ContractNameAccessKind) const { return type(); }
 
 	/// @param _internal false indicates external interface is concerned, true indicates internal interface is concerned.
 	/// @returns null when it is not accessible as a function.
@@ -1053,7 +1060,7 @@ class FunctionDefinition: public CallableDeclaration, public StructurallyDocumen
 	std::string externalIdentifierHex() const;
 
 	Type const* type() const override;
-	Type const* typeViaContractName() const override;
+	Type const* typeViaContractName(ContractNameAccessKind _accessKind) const override;
 
 	/// @param _internal false indicates external interface is concerned, true indicates internal interface is concerned.
 	/// @returns null when it is not accessible as a function.

libsolidity/ast/Types.cpp

@@ -404,7 +404,9 @@ std::set<FunctionDefinition const*, ASTNode::CompareByID> Type::operatorDefiniti
 				*identifierPath->annotation().referencedDeclaration
 			);
 			auto const* functionType = dynamic_cast<FunctionType const*>(
-				functionDefinition.libraryFunction() ? functionDefinition.typeViaContractName() : functionDefinition.type()
+				functionDefinition.libraryFunction() ?
+				functionDefinition.typeViaContractName(Declaration::ContractNameAccessKind::Library) :
+				functionDefinition.type()
 			);
 			solAssert(functionType && !functionType->parameterTypes().empty());
 
@@ -426,7 +428,7 @@ MemberList::MemberMap Type::attachedFunctions(Type const& _type, ASTNode const&
 		if (!_name)
 			_name = _function.name();
 		Type const* functionType =
-			_function.libraryFunction() ? _function.typeViaContractName() : _function.type();
+			_function.libraryFunction() ? _function.typeViaContractName(Declaration::ContractNameAccessKind::Library) : _function.type();
 		solAssert(functionType, "");
 		FunctionType const* withBoundFirstArgument =
 			dynamic_cast<FunctionType const&>(*functionType).withBoundFirstArgument();
@@ -3978,21 +3980,33 @@ MemberList::MemberMap TypeType::nativeMembers(ASTNode const* _currentScope) cons
 				if (declaration->name().empty())
 					continue;
 
-				if (!contract.isLibrary() && inDerivingScope && declaration->isVisibleInDerivedContracts())
+				if (contract.isLibrary() && declaration->isVisibleAsLibraryMember())
 				{
-					if (
-						auto const* functionDefinition = dynamic_cast<FunctionDefinition const*>(declaration);
-						functionDefinition && !functionDefinition->isImplemented()
-					)
-						members.emplace_back(declaration, declaration->typeViaContractName());
-					else
-						members.emplace_back(declaration, declaration->type());
+					// In case the contract is library, add only visible library members. visibility >= Internal.
+					members.emplace_back(
+						declaration,
+						declaration->typeViaContractName(Declaration::ContractNameAccessKind::Library)
+					);
+				}
+				else if (!contract.isLibrary() && inDerivingScope && declaration->visibility() > Visibility::Private)
+				{
+					// In case of regular contract (not library) and member is in the same deriving scope, add all
+					// members which are not private. Private members cannot be accessed via contract type name
+					// i.e C.fooPrivate.
+					members.emplace_back(
+						declaration,
+						declaration->typeViaContractName(Declaration::ContractNameAccessKind::Local)
+					);
+				}
+				else if (!contract.isLibrary() && !inDerivingScope && declaration->isVisibleViaContractInstance())
+				{
+					// In case of regular contract (not library) being accessed from foreign contract (not in deriving
+					// scope), add only externally visible members.
+					members.emplace_back(
+						declaration,
+						declaration->typeViaContractName(Declaration::ContractNameAccessKind::Foreign)
+					);
 				}
-				else if (
-					(contract.isLibrary() && declaration->isVisibleAsLibraryMember()) ||
-					declaration->isVisibleViaContractInstance()
-				)
-					members.emplace_back(declaration, declaration->typeViaContractName());
 			}
 		}
 	}