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

@@ -3184,6 +3184,31 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 				it = possibleMembers.erase(it);
 			else
 				++it;
+
+		// When both a native property and a library function share the same name,
+		// prefer functions when called with parentheses.
+		// This mirrors the identifier resolution pattern at lines 3693-3745 where
+		// VariableDeclarations are preferred without parentheses.
+		if (possibleMembers.size() > 1)
+		{
+			MemberList::MemberMap functions;
+			for (auto const& member: possibleMembers)
+				if (member.type->category() == Type::Category::Function)
+					functions.push_back(member);
+			if (!functions.empty() && functions.size() < possibleMembers.size())
+				possibleMembers = std::move(functions);
+		}
+	}
+	else if (initialMemberCount > 1)
+	{
+		// Without parentheses, prefer non-function members (native properties)
+		// over library functions attached via "using for".
+		MemberList::MemberMap nonFunctions;
+		for (auto const& member: possibleMembers)
+			if (member.type->category() != Type::Category::Function)
+				nonFunctions.push_back(member);
+		if (!nonFunctions.empty() && nonFunctions.size() < possibleMembers.size())
+			possibleMembers = std::move(nonFunctions);
 	}
 
 	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;
+    }
+}
+// ----