fix: disambiguate library functions vs native properties in member access

When both a native property (e.g., address.isContract) and a library
function with the same name are available via 'using for', disambiguate
based on call syntax:

- With parentheses: prefer library function (e.g., a.isContract())
- Without parentheses: prefer native property (e.g., a.isContract)

This allows OpenZeppelin's Address.isContract() library function to work
alongside Tron's native address.isContract property without conflict.

The fix mirrors the identifier resolution pattern in visit(Identifier)
where VariableDeclarations are preferred without parentheses (lines
3693-3745 in TypeChecker.cpp).

Fixes the error: 'Member "isContract" not unique after argument-dependent
lookup in address' when using OpenZeppelin contracts on Tron.

Author: yorhodes

libsolidity/analysis/TypeChecker.cpp

@@ -3173,17 +3173,33 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 	auto const& arguments = annotation.arguments;
 	MemberList::MemberMap possibleMembers = exprType->members(currentDefinitionScope()).membersByName(memberName);
 	size_t const initialMemberCount = possibleMembers.size();
-	if (initialMemberCount > 1 && arguments)
+	if (initialMemberCount > 1)
 	{
-		// do overload resolution
+		// Disambiguate when both native properties and library functions share the same name.
+		// With parentheses: prefer functions (do overload resolution, filter non-functions).
+		// Without parentheses: prefer non-functions (native properties).
+		// This mirrors the identifier resolution pattern at lines 3693-3745 where
+		// VariableDeclarations are preferred without parentheses.
 		for (auto it = possibleMembers.begin(); it != possibleMembers.end();)
-			if (
-				it->type->category() == Type::Category::Function &&
-				!dynamic_cast<FunctionType const&>(*it->type).canTakeArguments(*arguments, exprType)
-			)
-				it = possibleMembers.erase(it);
+		{
+			bool const isFunction = it->type->category() == Type::Category::Function;
+			if (arguments)
+			{
+				// With parentheses: remove non-functions, and functions that can't take the arguments
+				if (!isFunction || !dynamic_cast<FunctionType const&>(*it->type).canTakeArguments(*arguments, exprType))
+					it = possibleMembers.erase(it);
+				else
+					++it;
+			}
 			else
-				++it;
+			{
+				// Without parentheses: remove functions
+				if (isFunction)
+					it = possibleMembers.erase(it);
+				else
+					++it;
+			}
+		}
 	}
 
 	annotation.isConstant = false;

test/libsolidity/syntaxTests/memberLookup/library_function_vs_native_property_with_parens.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.0;
+
+// Test that library function is preferred over native property when called with parentheses.
+// This allows OpenZeppelin's Address.isContract() to work alongside Tron's native address.isContract property.
+library Address {
+    function isContract(address account) internal view returns (bool) {
+        return account.code.length > 0;
+    }
+}
+
+contract C {
+    using Address for address;
+
+    function check(address a) public view returns (bool) {
+        // With parentheses - should use library function
+        return a.isContract();
+    }
+}
+// ----

test/libsolidity/syntaxTests/memberLookup/library_function_vs_native_property_without_parens.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.0;
+
+// Test that native property is preferred over library function when accessed without parentheses.
+// This allows Tron's native address.isContract property to work alongside library functions.
+library Address {
+    function isContract(address account) internal view returns (bool) {
+        return account.code.length > 0;
+    }
+}
+
+contract C {
+    using Address for address;
+
+    function check(address a) public view returns (bool) {
+        // Without parentheses - should use native property
+        return a.isContract;
+    }
+}
+// ----

test/libsolidity/syntaxTests/memberLookup/native_isContract_property.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.8.0;
+
+// Test Tron's native address.isContract property works without library.
+contract C {
+    function check(address a) public view returns (bool) {
+        return a.isContract;
+    }
+}
+// ----